PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Descriptions of Sanyo Media Packets"""
0004 
0005 from prototypes import *
0006 
0007 # We use LSB for all integer like fields
0008 UINT=UINTlsb
0009 BOOL=BOOLlsb
0010 
0011 class sanyomediaheader(BaseProtogenClass):
0012     __fields=['fa', 'faset', 'command', 'pad']
0013 
0014     def __init__(self, *args, **kwargs):
0015         dict={}
0016         # What was supplied to this function
0017         dict.update(kwargs)
0018         # Parent constructor
0019         super(sanyomediaheader,self).__init__(**dict)
0020         if self.__class__ is sanyomediaheader:
0021             self._update(args,dict)
0022 
0023 
0024     def getfields(self):
0025         return self.__fields
0026 
0027 
0028     def _update(self, args, kwargs):
0029         super(sanyomediaheader,self)._update(args,kwargs)
0030         keys=kwargs.keys()
0031         for key in keys:
0032             if key in self.__fields:
0033                 setattr(self, key, kwargs[key])
0034                 del kwargs[key]
0035         # Were any unrecognized kwargs passed in?
0036         if __debug__:
0037             self._complainaboutunusedargs(sanyomediaheader,kwargs)
0038         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0039         # Make all P fields that haven't already been constructed
0040 
0041 
0042     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0043         'Writes this packet to the supplied buffer'
0044         self._bufferstartoffset=buf.getcurrentoffset()
0045         try: self.__field_fa
0046         except:
0047             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
0048         self.__field_fa.writetobuffer(buf)
0049         try: self.__field_faset
0050         except:
0051             self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x09})
0052         self.__field_faset.writetobuffer(buf)
0053         self.__field_command.writetobuffer(buf)
0054         try: self.__field_pad
0055         except:
0056             self.__field_pad=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0057         self.__field_pad.writetobuffer(buf)
0058         self._bufferendoffset=buf.getcurrentoffset()
0059         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0060 
0061 
0062     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0063         'Reads this packet from the supplied buffer'
0064         self._bufferstartoffset=buf.getcurrentoffset()
0065         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0066         self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
0067         self.__field_fa.readfrombuffer(buf)
0068         self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x09})
0069         self.__field_faset.readfrombuffer(buf)
0070         self.__field_command=UINT(**{'sizeinbytes': 2})
0071         self.__field_command.readfrombuffer(buf)
0072         self.__field_pad=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0073         self.__field_pad.readfrombuffer(buf)
0074         self._bufferendoffset=buf.getcurrentoffset()
0075 
0076 
0077     def __getfield_fa(self):
0078         try: self.__field_fa
0079         except:
0080             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
0081         return self.__field_fa.getvalue()
0082 
0083     def __setfield_fa(self, value):
0084         if isinstance(value,UINT):
0085             self.__field_fa=value
0086         else:
0087             self.__field_fa=UINT(value,**{'sizeinbytes': 2, 'constant': 0xfa})
0088 
0089     def __delfield_fa(self): del self.__field_fa
0090 
0091     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
0092 
0093     def __getfield_faset(self):
0094         try: self.__field_faset
0095         except:
0096             self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x09})
0097         return self.__field_faset.getvalue()
0098 
0099     def __setfield_faset(self, value):
0100         if isinstance(value,UINT):
0101             self.__field_faset=value
0102         else:
0103             self.__field_faset=UINT(value,**{'sizeinbytes': 1, 'default': 0x09})
0104 
0105     def __delfield_faset(self): del self.__field_faset
0106 
0107     faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None)
0108 
0109     def __getfield_command(self):
0110         return self.__field_command.getvalue()
0111 
0112     def __setfield_command(self, value):
0113         if isinstance(value,UINT):
0114             self.__field_command=value
0115         else:
0116             self.__field_command=UINT(value,**{'sizeinbytes': 2})
0117 
0118     def __delfield_command(self): del self.__field_command
0119 
0120     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0121 
0122     def __getfield_pad(self):
0123         try: self.__field_pad
0124         except:
0125             self.__field_pad=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0126         return self.__field_pad.getvalue()
0127 
0128     def __setfield_pad(self, value):
0129         if isinstance(value,UINT):
0130             self.__field_pad=value
0131         else:
0132             self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0133 
0134     def __delfield_pad(self): del self.__field_pad
0135 
0136     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0137 
0138     def iscontainer(self):
0139         return True
0140 
0141     def containerelements(self):
0142         yield ('fa', self.__field_fa, None)
0143         yield ('faset', self.__field_faset, None)
0144         yield ('command', self.__field_command, None)
0145         yield ('pad', self.__field_pad, None)
0146 
0147 
0148 
0149 
0150 class sanyochangedir(BaseProtogenClass):
0151     __fields=['header', 'pad', 'dirindex']
0152 
0153     def __init__(self, *args, **kwargs):
0154         dict={}
0155         # What was supplied to this function
0156         dict.update(kwargs)
0157         # Parent constructor
0158         super(sanyochangedir,self).__init__(**dict)
0159         if self.__class__ is sanyochangedir:
0160             self._update(args,dict)
0161 
0162 
0163     def getfields(self):
0164         return self.__fields
0165 
0166 
0167     def _update(self, args, kwargs):
0168         super(sanyochangedir,self)._update(args,kwargs)
0169         keys=kwargs.keys()
0170         for key in keys:
0171             if key in self.__fields:
0172                 setattr(self, key, kwargs[key])
0173                 del kwargs[key]
0174         # Were any unrecognized kwargs passed in?
0175         if __debug__:
0176             self._complainaboutunusedargs(sanyochangedir,kwargs)
0177         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0178         # Make all P fields that haven't already been constructed
0179 
0180 
0181     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0182         'Writes this packet to the supplied buffer'
0183         self._bufferstartoffset=buf.getcurrentoffset()
0184         try: self.__field_header
0185         except:
0186             self.__field_header=sanyomediaheader(**{'command': 0x71})
0187         self.__field_header.writetobuffer(buf)
0188         try: self.__field_pad
0189         except:
0190             self.__field_pad=UNKNOWN(**{'sizeinbytes': 170})
0191         self.__field_pad.writetobuffer(buf)
0192         self.__field_dirindex.writetobuffer(buf)
0193         self._bufferendoffset=buf.getcurrentoffset()
0194         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0195 
0196 
0197     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0198         'Reads this packet from the supplied buffer'
0199         self._bufferstartoffset=buf.getcurrentoffset()
0200         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0201         self.__field_header=sanyomediaheader(**{'command': 0x71})
0202         self.__field_header.readfrombuffer(buf)
0203         self.__field_pad=UNKNOWN(**{'sizeinbytes': 170})
0204         self.__field_pad.readfrombuffer(buf)
0205         self.__field_dirindex=UINT(**{'sizeinbytes': 2})
0206         self.__field_dirindex.readfrombuffer(buf)
0207         self._bufferendoffset=buf.getcurrentoffset()
0208 
0209 
0210     def __getfield_header(self):
0211         try: self.__field_header
0212         except:
0213             self.__field_header=sanyomediaheader(**{'command': 0x71})
0214         return self.__field_header.getvalue()
0215 
0216     def __setfield_header(self, value):
0217         if isinstance(value,sanyomediaheader):
0218             self.__field_header=value
0219         else:
0220             self.__field_header=sanyomediaheader(value,**{'command': 0x71})
0221 
0222     def __delfield_header(self): del self.__field_header
0223 
0224     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0225 
0226     def __getfield_pad(self):
0227         try: self.__field_pad
0228         except:
0229             self.__field_pad=UNKNOWN(**{'sizeinbytes': 170})
0230         return self.__field_pad.getvalue()
0231 
0232     def __setfield_pad(self, value):
0233         if isinstance(value,UNKNOWN):
0234             self.__field_pad=value
0235         else:
0236             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 170})
0237 
0238     def __delfield_pad(self): del self.__field_pad
0239 
0240     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0241 
0242     def __getfield_dirindex(self):
0243         return self.__field_dirindex.getvalue()
0244 
0245     def __setfield_dirindex(self, value):
0246         if isinstance(value,UINT):
0247             self.__field_dirindex=value
0248         else:
0249             self.__field_dirindex=UINT(value,**{'sizeinbytes': 2})
0250 
0251     def __delfield_dirindex(self): del self.__field_dirindex
0252 
0253     dirindex=property(__getfield_dirindex, __setfield_dirindex, __delfield_dirindex, None)
0254 
0255     def iscontainer(self):
0256         return True
0257 
0258     def containerelements(self):
0259         yield ('header', self.__field_header, None)
0260         yield ('pad', self.__field_pad, None)
0261         yield ('dirindex', self.__field_dirindex, None)
0262 
0263 
0264 
0265 
0266 class sanyochangedirresponse(BaseProtogenClass):
0267     __fields=['header', 'pad', 'status', 'dirindex']
0268 
0269     def __init__(self, *args, **kwargs):
0270         dict={}
0271         # What was supplied to this function
0272         dict.update(kwargs)
0273         # Parent constructor
0274         super(sanyochangedirresponse,self).__init__(**dict)
0275         if self.__class__ is sanyochangedirresponse:
0276             self._update(args,dict)
0277 
0278 
0279     def getfields(self):
0280         return self.__fields
0281 
0282 
0283     def _update(self, args, kwargs):
0284         super(sanyochangedirresponse,self)._update(args,kwargs)
0285         keys=kwargs.keys()
0286         for key in keys:
0287             if key in self.__fields:
0288                 setattr(self, key, kwargs[key])
0289                 del kwargs[key]
0290         # Were any unrecognized kwargs passed in?
0291         if __debug__:
0292             self._complainaboutunusedargs(sanyochangedirresponse,kwargs)
0293         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0294         # Make all P fields that haven't already been constructed
0295 
0296 
0297     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0298         'Writes this packet to the supplied buffer'
0299         self._bufferstartoffset=buf.getcurrentoffset()
0300         self.__field_header.writetobuffer(buf)
0301         try: self.__field_pad
0302         except:
0303             self.__field_pad=UNKNOWN(**{'sizeinbytes': 169})
0304         self.__field_pad.writetobuffer(buf)
0305         self.__field_status.writetobuffer(buf)
0306         self.__field_dirindex.writetobuffer(buf)
0307         self._bufferendoffset=buf.getcurrentoffset()
0308         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0309 
0310 
0311     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0312         'Reads this packet from the supplied buffer'
0313         self._bufferstartoffset=buf.getcurrentoffset()
0314         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0315         self.__field_header=sanyomediaheader()
0316         self.__field_header.readfrombuffer(buf)
0317         self.__field_pad=UNKNOWN(**{'sizeinbytes': 169})
0318         self.__field_pad.readfrombuffer(buf)
0319         self.__field_status=UINT(**{'sizeinbytes': 1})
0320         self.__field_status.readfrombuffer(buf)
0321         self.__field_dirindex=UINT(**{'sizeinbytes': 2})
0322         self.__field_dirindex.readfrombuffer(buf)
0323         self._bufferendoffset=buf.getcurrentoffset()
0324 
0325 
0326     def __getfield_header(self):
0327         return self.__field_header.getvalue()
0328 
0329     def __setfield_header(self, value):
0330         if isinstance(value,sanyomediaheader):
0331             self.__field_header=value
0332         else:
0333             self.__field_header=sanyomediaheader(value,)
0334 
0335     def __delfield_header(self): del self.__field_header
0336 
0337     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0338 
0339     def __getfield_pad(self):
0340         try: self.__field_pad
0341         except:
0342             self.__field_pad=UNKNOWN(**{'sizeinbytes': 169})
0343         return self.__field_pad.getvalue()
0344 
0345     def __setfield_pad(self, value):
0346         if isinstance(value,UNKNOWN):
0347             self.__field_pad=value
0348         else:
0349             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 169})
0350 
0351     def __delfield_pad(self): del self.__field_pad
0352 
0353     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0354 
0355     def __getfield_status(self):
0356         return self.__field_status.getvalue()
0357 
0358     def __setfield_status(self, value):
0359         if isinstance(value,UINT):
0360             self.__field_status=value
0361         else:
0362             self.__field_status=UINT(value,**{'sizeinbytes': 1})
0363 
0364     def __delfield_status(self): del self.__field_status
0365 
0366     status=property(__getfield_status, __setfield_status, __delfield_status, None)
0367 
0368     def __getfield_dirindex(self):
0369         return self.__field_dirindex.getvalue()
0370 
0371     def __setfield_dirindex(self, value):
0372         if isinstance(value,UINT):
0373             self.__field_dirindex=value
0374         else:
0375             self.__field_dirindex=UINT(value,**{'sizeinbytes': 2})
0376 
0377     def __delfield_dirindex(self): del self.__field_dirindex
0378 
0379     dirindex=property(__getfield_dirindex, __setfield_dirindex, __delfield_dirindex, None)
0380 
0381     def iscontainer(self):
0382         return True
0383 
0384     def containerelements(self):
0385         yield ('header', self.__field_header, None)
0386         yield ('pad', self.__field_pad, None)
0387         yield ('status', self.__field_status, None)
0388         yield ('dirindex', self.__field_dirindex, None)
0389 
0390 
0391 
0392 
0393 class sanyonumfilesrequest(BaseProtogenClass):
0394     __fields=['header', 'pad']
0395 
0396     def __init__(self, *args, **kwargs):
0397         dict={}
0398         # What was supplied to this function
0399         dict.update(kwargs)
0400         # Parent constructor
0401         super(sanyonumfilesrequest,self).__init__(**dict)
0402         if self.__class__ is sanyonumfilesrequest:
0403             self._update(args,dict)
0404 
0405 
0406     def getfields(self):
0407         return self.__fields
0408 
0409 
0410     def _update(self, args, kwargs):
0411         super(sanyonumfilesrequest,self)._update(args,kwargs)
0412         keys=kwargs.keys()
0413         for key in keys:
0414             if key in self.__fields:
0415                 setattr(self, key, kwargs[key])
0416                 del kwargs[key]
0417         # Were any unrecognized kwargs passed in?
0418         if __debug__:
0419             self._complainaboutunusedargs(sanyonumfilesrequest,kwargs)
0420         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0421         # Make all P fields that haven't already been constructed
0422 
0423 
0424     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0425         'Writes this packet to the supplied buffer'
0426         self._bufferstartoffset=buf.getcurrentoffset()
0427         try: self.__field_header
0428         except:
0429             self.__field_header=sanyomediaheader(**{'command': 0x72})
0430         self.__field_header.writetobuffer(buf)
0431         try: self.__field_pad
0432         except:
0433             self.__field_pad=UNKNOWN(**{'sizeinbytes': 172})
0434         self.__field_pad.writetobuffer(buf)
0435         self._bufferendoffset=buf.getcurrentoffset()
0436         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0437 
0438 
0439     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0440         'Reads this packet from the supplied buffer'
0441         self._bufferstartoffset=buf.getcurrentoffset()
0442         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0443         self.__field_header=sanyomediaheader(**{'command': 0x72})
0444         self.__field_header.readfrombuffer(buf)
0445         self.__field_pad=UNKNOWN(**{'sizeinbytes': 172})
0446         self.__field_pad.readfrombuffer(buf)
0447         self._bufferendoffset=buf.getcurrentoffset()
0448 
0449 
0450     def __getfield_header(self):
0451         try: self.__field_header
0452         except:
0453             self.__field_header=sanyomediaheader(**{'command': 0x72})
0454         return self.__field_header.getvalue()
0455 
0456     def __setfield_header(self, value):
0457         if isinstance(value,sanyomediaheader):
0458             self.__field_header=value
0459         else:
0460             self.__field_header=sanyomediaheader(value,**{'command': 0x72})
0461 
0462     def __delfield_header(self): del self.__field_header
0463 
0464     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0465 
0466     def __getfield_pad(self):
0467         try: self.__field_pad
0468         except:
0469             self.__field_pad=UNKNOWN(**{'sizeinbytes': 172})
0470         return self.__field_pad.getvalue()
0471 
0472     def __setfield_pad(self, value):
0473         if isinstance(value,UNKNOWN):
0474             self.__field_pad=value
0475         else:
0476             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 172})
0477 
0478     def __delfield_pad(self): del self.__field_pad
0479 
0480     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0481 
0482     def iscontainer(self):
0483         return True
0484 
0485     def containerelements(self):
0486         yield ('header', self.__field_header, None)
0487         yield ('pad', self.__field_pad, None)
0488 
0489 
0490 
0491 
0492 class sanyonumfilesresponse(BaseProtogenClass):
0493     __fields=['header', 'pad1', 'count', 'pad2']
0494 
0495     def __init__(self, *args, **kwargs):
0496         dict={}
0497         # What was supplied to this function
0498         dict.update(kwargs)
0499         # Parent constructor
0500         super(sanyonumfilesresponse,self).__init__(**dict)
0501         if self.__class__ is sanyonumfilesresponse:
0502             self._update(args,dict)
0503 
0504 
0505     def getfields(self):
0506         return self.__fields
0507 
0508 
0509     def _update(self, args, kwargs):
0510         super(sanyonumfilesresponse,self)._update(args,kwargs)
0511         keys=kwargs.keys()
0512         for key in keys:
0513             if key in self.__fields:
0514                 setattr(self, key, kwargs[key])
0515                 del kwargs[key]
0516         # Were any unrecognized kwargs passed in?
0517         if __debug__:
0518             self._complainaboutunusedargs(sanyonumfilesresponse,kwargs)
0519         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0520         # Make all P fields that haven't already been constructed
0521 
0522 
0523     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0524         'Writes this packet to the supplied buffer'
0525         self._bufferstartoffset=buf.getcurrentoffset()
0526         self.__field_header.writetobuffer(buf)
0527         try: self.__field_pad1
0528         except:
0529             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 165})
0530         self.__field_pad1.writetobuffer(buf)
0531         self.__field_count.writetobuffer(buf)
0532         try: self.__field_pad2
0533         except:
0534             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 6})
0535         self.__field_pad2.writetobuffer(buf)
0536         self._bufferendoffset=buf.getcurrentoffset()
0537         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0538 
0539 
0540     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0541         'Reads this packet from the supplied buffer'
0542         self._bufferstartoffset=buf.getcurrentoffset()
0543         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0544         self.__field_header=sanyomediaheader()
0545         self.__field_header.readfrombuffer(buf)
0546         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 165})
0547         self.__field_pad1.readfrombuffer(buf)
0548         self.__field_count=UINT(**{'sizeinbytes': 1})
0549         self.__field_count.readfrombuffer(buf)
0550         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 6})
0551         self.__field_pad2.readfrombuffer(buf)
0552         self._bufferendoffset=buf.getcurrentoffset()
0553 
0554 
0555     def __getfield_header(self):
0556         return self.__field_header.getvalue()
0557 
0558     def __setfield_header(self, value):
0559         if isinstance(value,sanyomediaheader):
0560             self.__field_header=value
0561         else:
0562             self.__field_header=sanyomediaheader(value,)
0563 
0564     def __delfield_header(self): del self.__field_header
0565 
0566     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0567 
0568     def __getfield_pad1(self):
0569         try: self.__field_pad1
0570         except:
0571             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 165})
0572         return self.__field_pad1.getvalue()
0573 
0574     def __setfield_pad1(self, value):
0575         if isinstance(value,UNKNOWN):
0576             self.__field_pad1=value
0577         else:
0578             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 165})
0579 
0580     def __delfield_pad1(self): del self.__field_pad1
0581 
0582     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
0583 
0584     def __getfield_count(self):
0585         return self.__field_count.getvalue()
0586 
0587     def __setfield_count(self, value):
0588         if isinstance(value,UINT):
0589             self.__field_count=value
0590         else:
0591             self.__field_count=UINT(value,**{'sizeinbytes': 1})
0592 
0593     def __delfield_count(self): del self.__field_count
0594 
0595     count=property(__getfield_count, __setfield_count, __delfield_count, None)
0596 
0597     def __getfield_pad2(self):
0598         try: self.__field_pad2
0599         except:
0600             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 6})
0601         return self.__field_pad2.getvalue()
0602 
0603     def __setfield_pad2(self, value):
0604         if isinstance(value,UNKNOWN):
0605             self.__field_pad2=value
0606         else:
0607             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 6})
0608 
0609     def __delfield_pad2(self): del self.__field_pad2
0610 
0611     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
0612 
0613     def iscontainer(self):
0614         return True
0615 
0616     def containerelements(self):
0617         yield ('header', self.__field_header, None)
0618         yield ('pad1', self.__field_pad1, None)
0619         yield ('count', self.__field_count, None)
0620         yield ('pad2', self.__field_pad2, None)
0621 
0622 
0623 
0624 
0625 class sanyomediafilenamerequest(BaseProtogenClass):
0626     __fields=['header', 'pad1', 'index', 'pad2']
0627 
0628     def __init__(self, *args, **kwargs):
0629         dict={}
0630         # What was supplied to this function
0631         dict.update(kwargs)
0632         # Parent constructor
0633         super(sanyomediafilenamerequest,self).__init__(**dict)
0634         if self.__class__ is sanyomediafilenamerequest:
0635             self._update(args,dict)
0636 
0637 
0638     def getfields(self):
0639         return self.__fields
0640 
0641 
0642     def _update(self, args, kwargs):
0643         super(sanyomediafilenamerequest,self)._update(args,kwargs)
0644         keys=kwargs.keys()
0645         for key in keys:
0646             if key in self.__fields:
0647                 setattr(self, key, kwargs[key])
0648                 del kwargs[key]
0649         # Were any unrecognized kwargs passed in?
0650         if __debug__:
0651             self._complainaboutunusedargs(sanyomediafilenamerequest,kwargs)
0652         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0653         # Make all P fields that haven't already been constructed
0654 
0655 
0656     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0657         'Writes this packet to the supplied buffer'
0658         self._bufferstartoffset=buf.getcurrentoffset()
0659         try: self.__field_header
0660         except:
0661             self.__field_header=sanyomediaheader(**{'command': 0x73})
0662         self.__field_header.writetobuffer(buf)
0663         try: self.__field_pad1
0664         except:
0665             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 161})
0666         self.__field_pad1.writetobuffer(buf)
0667         self.__field_index.writetobuffer(buf)
0668         try: self.__field_pad2
0669         except:
0670             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 10})
0671         self.__field_pad2.writetobuffer(buf)
0672         self._bufferendoffset=buf.getcurrentoffset()
0673         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0674 
0675 
0676     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0677         'Reads this packet from the supplied buffer'
0678         self._bufferstartoffset=buf.getcurrentoffset()
0679         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0680         self.__field_header=sanyomediaheader(**{'command': 0x73})
0681         self.__field_header.readfrombuffer(buf)
0682         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 161})
0683         self.__field_pad1.readfrombuffer(buf)
0684         self.__field_index=UINT(**{'sizeinbytes': 1})
0685         self.__field_index.readfrombuffer(buf)
0686         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 10})
0687         self.__field_pad2.readfrombuffer(buf)
0688         self._bufferendoffset=buf.getcurrentoffset()
0689 
0690 
0691     def __getfield_header(self):
0692         try: self.__field_header
0693         except:
0694             self.__field_header=sanyomediaheader(**{'command': 0x73})
0695         return self.__field_header.getvalue()
0696 
0697     def __setfield_header(self, value):
0698         if isinstance(value,sanyomediaheader):
0699             self.__field_header=value
0700         else:
0701             self.__field_header=sanyomediaheader(value,**{'command': 0x73})
0702 
0703     def __delfield_header(self): del self.__field_header
0704 
0705     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0706 
0707     def __getfield_pad1(self):
0708         try: self.__field_pad1
0709         except:
0710             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 161})
0711         return self.__field_pad1.getvalue()
0712 
0713     def __setfield_pad1(self, value):
0714         if isinstance(value,UNKNOWN):
0715             self.__field_pad1=value
0716         else:
0717             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 161})
0718 
0719     def __delfield_pad1(self): del self.__field_pad1
0720 
0721     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
0722 
0723     def __getfield_index(self):
0724         return self.__field_index.getvalue()
0725 
0726     def __setfield_index(self, value):
0727         if isinstance(value,UINT):
0728             self.__field_index=value
0729         else:
0730             self.__field_index=UINT(value,**{'sizeinbytes': 1})
0731 
0732     def __delfield_index(self): del self.__field_index
0733 
0734     index=property(__getfield_index, __setfield_index, __delfield_index, None)
0735 
0736     def __getfield_pad2(self):
0737         try: self.__field_pad2
0738         except:
0739             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 10})
0740         return self.__field_pad2.getvalue()
0741 
0742     def __setfield_pad2(self, value):
0743         if isinstance(value,UNKNOWN):
0744             self.__field_pad2=value
0745         else:
0746             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 10})
0747 
0748     def __delfield_pad2(self): del self.__field_pad2
0749 
0750     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
0751 
0752     def iscontainer(self):
0753         return True
0754 
0755     def containerelements(self):
0756         yield ('header', self.__field_header, None)
0757         yield ('pad1', self.__field_pad1, None)
0758         yield ('index', self.__field_index, None)
0759         yield ('pad2', self.__field_pad2, None)
0760 
0761 
0762 
0763 
0764 class sanyomediafilenameresponse(BaseProtogenClass):
0765     __fields=['header', 'pad1', 'filename', 'num1', 'pad2', 'num2', 'pad3', 'num3', 'pad4', 'num4', 'pad5']
0766 
0767     def __init__(self, *args, **kwargs):
0768         dict={}
0769         # What was supplied to this function
0770         dict.update(kwargs)
0771         # Parent constructor
0772         super(sanyomediafilenameresponse,self).__init__(**dict)
0773         if self.__class__ is sanyomediafilenameresponse:
0774             self._update(args,dict)
0775 
0776 
0777     def getfields(self):
0778         return self.__fields
0779 
0780 
0781     def _update(self, args, kwargs):
0782         super(sanyomediafilenameresponse,self)._update(args,kwargs)
0783         keys=kwargs.keys()
0784         for key in keys:
0785             if key in self.__fields:
0786                 setattr(self, key, kwargs[key])
0787                 del kwargs[key]
0788         # Were any unrecognized kwargs passed in?
0789         if __debug__:
0790             self._complainaboutunusedargs(sanyomediafilenameresponse,kwargs)
0791         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0792         # Make all P fields that haven't already been constructed
0793 
0794 
0795     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0796         'Writes this packet to the supplied buffer'
0797         self._bufferstartoffset=buf.getcurrentoffset()
0798         self.__field_header.writetobuffer(buf)
0799         self.__field_pad1.writetobuffer(buf)
0800         self.__field_filename.writetobuffer(buf)
0801         self.__field_num1.writetobuffer(buf)
0802         self.__field_pad2.writetobuffer(buf)
0803         self.__field_num2.writetobuffer(buf)
0804         self.__field_pad3.writetobuffer(buf)
0805         self.__field_num3.writetobuffer(buf)
0806         self.__field_pad4.writetobuffer(buf)
0807         self.__field_num4.writetobuffer(buf)
0808         self.__field_pad5.writetobuffer(buf)
0809         self._bufferendoffset=buf.getcurrentoffset()
0810         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0811 
0812 
0813     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0814         'Reads this packet from the supplied buffer'
0815         self._bufferstartoffset=buf.getcurrentoffset()
0816         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0817         self.__field_header=sanyomediaheader()
0818         self.__field_header.readfrombuffer(buf)
0819         self.__field_pad1=UINT(**{'sizeinbytes': 1})
0820         self.__field_pad1.readfrombuffer(buf)
0821         self.__field_filename=USTRING(**{'sizeinbytes': 154})
0822         self.__field_filename.readfrombuffer(buf)
0823         self.__field_num1=UINT(**{'sizeinbytes': 1})
0824         self.__field_num1.readfrombuffer(buf)
0825         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
0826         self.__field_pad2.readfrombuffer(buf)
0827         self.__field_num2=UINT(**{'sizeinbytes': 1})
0828         self.__field_num2.readfrombuffer(buf)
0829         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
0830         self.__field_pad3.readfrombuffer(buf)
0831         self.__field_num3=UINT(**{'sizeinbytes': 1})
0832         self.__field_num3.readfrombuffer(buf)
0833         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
0834         self.__field_pad4.readfrombuffer(buf)
0835         self.__field_num4=UINT(**{'sizeinbytes': 1})
0836         self.__field_num4.readfrombuffer(buf)
0837         self.__field_pad5=UNKNOWN(**{'sizeinbytes': 10})
0838         self.__field_pad5.readfrombuffer(buf)
0839         self._bufferendoffset=buf.getcurrentoffset()
0840 
0841 
0842     def __getfield_header(self):
0843         return self.__field_header.getvalue()
0844 
0845     def __setfield_header(self, value):
0846         if isinstance(value,sanyomediaheader):
0847             self.__field_header=value
0848         else:
0849             self.__field_header=sanyomediaheader(value,)
0850 
0851     def __delfield_header(self): del self.__field_header
0852 
0853     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0854 
0855     def __getfield_pad1(self):
0856         return self.__field_pad1.getvalue()
0857 
0858     def __setfield_pad1(self, value):
0859         if isinstance(value,UINT):
0860             self.__field_pad1=value
0861         else:
0862             self.__field_pad1=UINT(value,**{'sizeinbytes': 1})
0863 
0864     def __delfield_pad1(self): del self.__field_pad1
0865 
0866     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
0867 
0868     def __getfield_filename(self):
0869         return self.__field_filename.getvalue()
0870 
0871     def __setfield_filename(self, value):
0872         if isinstance(value,USTRING):
0873             self.__field_filename=value
0874         else:
0875             self.__field_filename=USTRING(value,**{'sizeinbytes': 154})
0876 
0877     def __delfield_filename(self): del self.__field_filename
0878 
0879     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
0880 
0881     def __getfield_num1(self):
0882         return self.__field_num1.getvalue()
0883 
0884     def __setfield_num1(self, value):
0885         if isinstance(value,UINT):
0886             self.__field_num1=value
0887         else:
0888             self.__field_num1=UINT(value,**{'sizeinbytes': 1})
0889 
0890     def __delfield_num1(self): del self.__field_num1
0891 
0892     num1=property(__getfield_num1, __setfield_num1, __delfield_num1, None)
0893 
0894     def __getfield_pad2(self):
0895         return self.__field_pad2.getvalue()
0896 
0897     def __setfield_pad2(self, value):
0898         if isinstance(value,UNKNOWN):
0899             self.__field_pad2=value
0900         else:
0901             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1})
0902 
0903     def __delfield_pad2(self): del self.__field_pad2
0904 
0905     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
0906 
0907     def __getfield_num2(self):
0908         return self.__field_num2.getvalue()
0909 
0910     def __setfield_num2(self, value):
0911         if isinstance(value,UINT):
0912             self.__field_num2=value
0913         else:
0914             self.__field_num2=UINT(value,**{'sizeinbytes': 1})
0915 
0916     def __delfield_num2(self): del self.__field_num2
0917 
0918     num2=property(__getfield_num2, __setfield_num2, __delfield_num2, None)
0919 
0920     def __getfield_pad3(self):
0921         return self.__field_pad3.getvalue()
0922 
0923     def __setfield_pad3(self, value):
0924         if isinstance(value,UNKNOWN):
0925             self.__field_pad3=value
0926         else:
0927             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
0928 
0929     def __delfield_pad3(self): del self.__field_pad3
0930 
0931     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
0932 
0933     def __getfield_num3(self):
0934         return self.__field_num3.getvalue()
0935 
0936     def __setfield_num3(self, value):
0937         if isinstance(value,UINT):
0938             self.__field_num3=value
0939         else:
0940             self.__field_num3=UINT(value,**{'sizeinbytes': 1})
0941 
0942     def __delfield_num3(self): del self.__field_num3
0943 
0944     num3=property(__getfield_num3, __setfield_num3, __delfield_num3, None)
0945 
0946     def __getfield_pad4(self):
0947         return self.__field_pad4.getvalue()
0948 
0949     def __setfield_pad4(self, value):
0950         if isinstance(value,UNKNOWN):
0951             self.__field_pad4=value
0952         else:
0953             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1})
0954 
0955     def __delfield_pad4(self): del self.__field_pad4
0956 
0957     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None)
0958 
0959     def __getfield_num4(self):
0960         return self.__field_num4.getvalue()
0961 
0962     def __setfield_num4(self, value):
0963         if isinstance(value,UINT):
0964             self.__field_num4=value
0965         else:
0966             self.__field_num4=UINT(value,**{'sizeinbytes': 1})
0967 
0968     def __delfield_num4(self): del self.__field_num4
0969 
0970     num4=property(__getfield_num4, __setfield_num4, __delfield_num4, None)
0971 
0972     def __getfield_pad5(self):
0973         return self.__field_pad5.getvalue()
0974 
0975     def __setfield_pad5(self, value):
0976         if isinstance(value,UNKNOWN):
0977             self.__field_pad5=value
0978         else:
0979             self.__field_pad5=UNKNOWN(value,**{'sizeinbytes': 10})
0980 
0981     def __delfield_pad5(self): del self.__field_pad5
0982 
0983     pad5=property(__getfield_pad5, __setfield_pad5, __delfield_pad5, None)
0984 
0985     def iscontainer(self):
0986         return True
0987 
0988     def containerelements(self):
0989         yield ('header', self.__field_header, None)
0990         yield ('pad1', self.__field_pad1, None)
0991         yield ('filename', self.__field_filename, None)
0992         yield ('num1', self.__field_num1, None)
0993         yield ('pad2', self.__field_pad2, None)
0994         yield ('num2', self.__field_num2, None)
0995         yield ('pad3', self.__field_pad3, None)
0996         yield ('num3', self.__field_num3, None)
0997         yield ('pad4', self.__field_pad4, None)
0998         yield ('num4', self.__field_num4, None)
0999         yield ('pad5', self.__field_pad5, None)
1000 
1001 
1002 
1003 
1004 class sanyomediafragmentrequest(BaseProtogenClass):
1005     __fields=['header', 'pad1', 'fileindex', 'pad2']
1006 
1007     def __init__(self, *args, **kwargs):
1008         dict={}
1009         # What was supplied to this function
1010         dict.update(kwargs)
1011         # Parent constructor
1012         super(sanyomediafragmentrequest,self).__init__(**dict)
1013         if self.__class__ is sanyomediafragmentrequest:
1014             self._update(args,dict)
1015 
1016 
1017     def getfields(self):
1018         return self.__fields
1019 
1020 
1021     def _update(self, args, kwargs):
1022         super(sanyomediafragmentrequest,self)._update(args,kwargs)
1023         keys=kwargs.keys()
1024         for key in keys:
1025             if key in self.__fields:
1026                 setattr(self, key, kwargs[key])
1027                 del kwargs[key]
1028         # Were any unrecognized kwargs passed in?
1029         if __debug__:
1030             self._complainaboutunusedargs(sanyomediafragmentrequest,kwargs)
1031         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1032         # Make all P fields that haven't already been constructed
1033 
1034 
1035     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1036         'Writes this packet to the supplied buffer'
1037         self._bufferstartoffset=buf.getcurrentoffset()
1038         try: self.__field_header
1039         except:
1040             self.__field_header=sanyomediaheader(**{'command': 0x74})
1041         self.__field_header.writetobuffer(buf)
1042         try: self.__field_pad1
1043         except:
1044             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 155})
1045         self.__field_pad1.writetobuffer(buf)
1046         self.__field_fileindex.writetobuffer(buf)
1047         try: self.__field_pad2
1048         except:
1049             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 16})
1050         self.__field_pad2.writetobuffer(buf)
1051         self._bufferendoffset=buf.getcurrentoffset()
1052         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1053 
1054 
1055     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1056         'Reads this packet from the supplied buffer'
1057         self._bufferstartoffset=buf.getcurrentoffset()
1058         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1059         self.__field_header=sanyomediaheader(**{'command': 0x74})
1060         self.__field_header.readfrombuffer(buf)
1061         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 155})
1062         self.__field_pad1.readfrombuffer(buf)
1063         self.__field_fileindex=UINT(**{'sizeinbytes': 1})
1064         self.__field_fileindex.readfrombuffer(buf)
1065         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 16})
1066         self.__field_pad2.readfrombuffer(buf)
1067         self._bufferendoffset=buf.getcurrentoffset()
1068 
1069 
1070     def __getfield_header(self):
1071         try: self.__field_header
1072         except:
1073             self.__field_header=sanyomediaheader(**{'command': 0x74})
1074         return self.__field_header.getvalue()
1075 
1076     def __setfield_header(self, value):
1077         if isinstance(value,sanyomediaheader):
1078             self.__field_header=value
1079         else:
1080             self.__field_header=sanyomediaheader(value,**{'command': 0x74})
1081 
1082     def __delfield_header(self): del self.__field_header
1083 
1084     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1085 
1086     def __getfield_pad1(self):
1087         try: self.__field_pad1
1088         except:
1089             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 155})
1090         return self.__field_pad1.getvalue()
1091 
1092     def __setfield_pad1(self, value):
1093         if isinstance(value,UNKNOWN):
1094             self.__field_pad1=value
1095         else:
1096             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 155})
1097 
1098     def __delfield_pad1(self): del self.__field_pad1
1099 
1100     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1101 
1102     def __getfield_fileindex(self):
1103         return self.__field_fileindex.getvalue()
1104 
1105     def __setfield_fileindex(self, value):
1106         if isinstance(value,UINT):
1107             self.__field_fileindex=value
1108         else:
1109             self.__field_fileindex=UINT(value,**{'sizeinbytes': 1})
1110 
1111     def __delfield_fileindex(self): del self.__field_fileindex
1112 
1113     fileindex=property(__getfield_fileindex, __setfield_fileindex, __delfield_fileindex, None)
1114 
1115     def __getfield_pad2(self):
1116         try: self.__field_pad2
1117         except:
1118             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 16})
1119         return self.__field_pad2.getvalue()
1120 
1121     def __setfield_pad2(self, value):
1122         if isinstance(value,UNKNOWN):
1123             self.__field_pad2=value
1124         else:
1125             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 16})
1126 
1127     def __delfield_pad2(self): del self.__field_pad2
1128 
1129     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1130 
1131     def iscontainer(self):
1132         return True
1133 
1134     def containerelements(self):
1135         yield ('header', self.__field_header, None)
1136         yield ('pad1', self.__field_pad1, None)
1137         yield ('fileindex', self.__field_fileindex, None)
1138         yield ('pad2', self.__field_pad2, None)
1139 
1140 
1141 
1142 
1143 class sanyomediafragmentresponse(BaseProtogenClass):
1144     __fields=['header', 'pad1', 'data', 'length', 'pad2', 'fileindex', 'pad3', 'more']
1145 
1146     def __init__(self, *args, **kwargs):
1147         dict={}
1148         # What was supplied to this function
1149         dict.update(kwargs)
1150         # Parent constructor
1151         super(sanyomediafragmentresponse,self).__init__(**dict)
1152         if self.__class__ is sanyomediafragmentresponse:
1153             self._update(args,dict)
1154 
1155 
1156     def getfields(self):
1157         return self.__fields
1158 
1159 
1160     def _update(self, args, kwargs):
1161         super(sanyomediafragmentresponse,self)._update(args,kwargs)
1162         keys=kwargs.keys()
1163         for key in keys:
1164             if key in self.__fields:
1165                 setattr(self, key, kwargs[key])
1166                 del kwargs[key]
1167         # Were any unrecognized kwargs passed in?
1168         if __debug__:
1169             self._complainaboutunusedargs(sanyomediafragmentresponse,kwargs)
1170         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1171         # Make all P fields that haven't already been constructed
1172 
1173 
1174     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1175         'Writes this packet to the supplied buffer'
1176         self._bufferstartoffset=buf.getcurrentoffset()
1177         self.__field_header.writetobuffer(buf)
1178         self.__field_pad1.writetobuffer(buf)
1179         self.__field_data.writetobuffer(buf)
1180         self.__field_length.writetobuffer(buf)
1181         self.__field_pad2.writetobuffer(buf)
1182         self.__field_fileindex.writetobuffer(buf)
1183         self.__field_pad3.writetobuffer(buf)
1184         self.__field_more.writetobuffer(buf)
1185         self._bufferendoffset=buf.getcurrentoffset()
1186         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1187 
1188 
1189     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1190         'Reads this packet from the supplied buffer'
1191         self._bufferstartoffset=buf.getcurrentoffset()
1192         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1193         self.__field_header=sanyomediaheader()
1194         self.__field_header.readfrombuffer(buf)
1195         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
1196         self.__field_pad1.readfrombuffer(buf)
1197         self.__field_data=DATA(**{'sizeinbytes': 150})
1198         self.__field_data.readfrombuffer(buf)
1199         self.__field_length=UINT(**{'sizeinbytes': 1})
1200         self.__field_length.readfrombuffer(buf)
1201         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3})
1202         self.__field_pad2.readfrombuffer(buf)
1203         self.__field_fileindex=UINT(**{'sizeinbytes': 1})
1204         self.__field_fileindex.readfrombuffer(buf)
1205         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 15})
1206         self.__field_pad3.readfrombuffer(buf)
1207         self.__field_more=UINT(**{'sizeinbytes': 1})
1208         self.__field_more.readfrombuffer(buf)
1209         self._bufferendoffset=buf.getcurrentoffset()
1210 
1211 
1212     def __getfield_header(self):
1213         return self.__field_header.getvalue()
1214 
1215     def __setfield_header(self, value):
1216         if isinstance(value,sanyomediaheader):
1217             self.__field_header=value
1218         else:
1219             self.__field_header=sanyomediaheader(value,)
1220 
1221     def __delfield_header(self): del self.__field_header
1222 
1223     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1224 
1225     def __getfield_pad1(self):
1226         return self.__field_pad1.getvalue()
1227 
1228     def __setfield_pad1(self, value):
1229         if isinstance(value,UNKNOWN):
1230             self.__field_pad1=value
1231         else:
1232             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
1233 
1234     def __delfield_pad1(self): del self.__field_pad1
1235 
1236     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1237 
1238     def __getfield_data(self):
1239         return self.__field_data.getvalue()
1240 
1241     def __setfield_data(self, value):
1242         if isinstance(value,DATA):
1243             self.__field_data=value
1244         else:
1245             self.__field_data=DATA(value,**{'sizeinbytes': 150})
1246 
1247     def __delfield_data(self): del self.__field_data
1248 
1249     data=property(__getfield_data, __setfield_data, __delfield_data, None)
1250 
1251     def __getfield_length(self):
1252         return self.__field_length.getvalue()
1253 
1254     def __setfield_length(self, value):
1255         if isinstance(value,UINT):
1256             self.__field_length=value
1257         else:
1258             self.__field_length=UINT(value,**{'sizeinbytes': 1})
1259 
1260     def __delfield_length(self): del self.__field_length
1261 
1262     length=property(__getfield_length, __setfield_length, __delfield_length, None)
1263 
1264     def __getfield_pad2(self):
1265         return self.__field_pad2.getvalue()
1266 
1267     def __setfield_pad2(self, value):
1268         if isinstance(value,UNKNOWN):
1269             self.__field_pad2=value
1270         else:
1271             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 3})
1272 
1273     def __delfield_pad2(self): del self.__field_pad2
1274 
1275     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1276 
1277     def __getfield_fileindex(self):
1278         return self.__field_fileindex.getvalue()
1279 
1280     def __setfield_fileindex(self, value):
1281         if isinstance(value,UINT):
1282             self.__field_fileindex=value
1283         else:
1284             self.__field_fileindex=UINT(value,**{'sizeinbytes': 1})
1285 
1286     def __delfield_fileindex(self): del self.__field_fileindex
1287 
1288     fileindex=property(__getfield_fileindex, __setfield_fileindex, __delfield_fileindex, None)
1289 
1290     def __getfield_pad3(self):
1291         return self.__field_pad3.getvalue()
1292 
1293     def __setfield_pad3(self, value):
1294         if isinstance(value,UNKNOWN):
1295             self.__field_pad3=value
1296         else:
1297             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 15})
1298 
1299     def __delfield_pad3(self): del self.__field_pad3
1300 
1301     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
1302 
1303     def __getfield_more(self):
1304         return self.__field_more.getvalue()
1305 
1306     def __setfield_more(self, value):
1307         if isinstance(value,UINT):
1308             self.__field_more=value
1309         else:
1310             self.__field_more=UINT(value,**{'sizeinbytes': 1})
1311 
1312     def __delfield_more(self): del self.__field_more
1313 
1314     more=property(__getfield_more, __setfield_more, __delfield_more, None)
1315 
1316     def iscontainer(self):
1317         return True
1318 
1319     def containerelements(self):
1320         yield ('header', self.__field_header, None)
1321         yield ('pad1', self.__field_pad1, None)
1322         yield ('data', self.__field_data, None)
1323         yield ('length', self.__field_length, None)
1324         yield ('pad2', self.__field_pad2, None)
1325         yield ('fileindex', self.__field_fileindex, None)
1326         yield ('pad3', self.__field_pad3, None)
1327         yield ('more', self.__field_more, None)
1328 
1329 
1330 
1331 
1332 class sanyomediafilegragment(BaseProtogenClass):
1333     __fields=['header', 'word', 'len', 'data', 'pad']
1334 
1335     def __init__(self, *args, **kwargs):
1336         dict={}
1337         # What was supplied to this function
1338         dict.update(kwargs)
1339         # Parent constructor
1340         super(sanyomediafilegragment,self).__init__(**dict)
1341         if self.__class__ is sanyomediafilegragment:
1342             self._update(args,dict)
1343 
1344 
1345     def getfields(self):
1346         return self.__fields
1347 
1348 
1349     def _update(self, args, kwargs):
1350         super(sanyomediafilegragment,self)._update(args,kwargs)
1351         keys=kwargs.keys()
1352         for key in keys:
1353             if key in self.__fields:
1354                 setattr(self, key, kwargs[key])
1355                 del kwargs[key]
1356         # Were any unrecognized kwargs passed in?
1357         if __debug__:
1358             self._complainaboutunusedargs(sanyomediafilegragment,kwargs)
1359         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1360         # Make all P fields that haven't already been constructed
1361 
1362 
1363     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1364         'Writes this packet to the supplied buffer'
1365         self._bufferstartoffset=buf.getcurrentoffset()
1366         try: self.__field_header
1367         except:
1368             self.__field_header=sanyomediaheader()
1369         self.__field_header.writetobuffer(buf)
1370         try: self.__field_word
1371         except:
1372             self.__field_word=UINT(**{'sizeinbytes': 2, 'constant': 0})
1373         self.__field_word.writetobuffer(buf)
1374         try: self.__field_len
1375         except:
1376             self.__field_len=UINT(**{'sizeinbytes': 1, 'constant': 150})
1377         self.__field_len.writetobuffer(buf)
1378         self.__field_data.writetobuffer(buf)
1379         try: self.__field_pad
1380         except:
1381             self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1382         self.__field_pad.writetobuffer(buf)
1383         self._bufferendoffset=buf.getcurrentoffset()
1384         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1385 
1386 
1387     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1388         'Reads this packet from the supplied buffer'
1389         self._bufferstartoffset=buf.getcurrentoffset()
1390         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1391         self.__field_header=sanyomediaheader()
1392         self.__field_header.readfrombuffer(buf)
1393         self.__field_word=UINT(**{'sizeinbytes': 2, 'constant': 0})
1394         self.__field_word.readfrombuffer(buf)
1395         self.__field_len=UINT(**{'sizeinbytes': 1, 'constant': 150})
1396         self.__field_len.readfrombuffer(buf)
1397         self.__field_data=DATA(**{'sizeinbytes': 150})
1398         self.__field_data.readfrombuffer(buf)
1399         self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1400         self.__field_pad.readfrombuffer(buf)
1401         self._bufferendoffset=buf.getcurrentoffset()
1402 
1403 
1404     def __getfield_header(self):
1405         try: self.__field_header
1406         except:
1407             self.__field_header=sanyomediaheader()
1408         return self.__field_header.getvalue()
1409 
1410     def __setfield_header(self, value):
1411         if isinstance(value,sanyomediaheader):
1412             self.__field_header=value
1413         else:
1414             self.__field_header=sanyomediaheader(value,)
1415 
1416     def __delfield_header(self): del self.__field_header
1417 
1418     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1419 
1420     def __getfield_word(self):
1421         try: self.__field_word
1422         except:
1423             self.__field_word=UINT(**{'sizeinbytes': 2, 'constant': 0})
1424         return self.__field_word.getvalue()
1425 
1426     def __setfield_word(self, value):
1427         if isinstance(value,UINT):
1428             self.__field_word=value
1429         else:
1430             self.__field_word=UINT(value,**{'sizeinbytes': 2, 'constant': 0})
1431 
1432     def __delfield_word(self): del self.__field_word
1433 
1434     word=property(__getfield_word, __setfield_word, __delfield_word, None)
1435 
1436     def __getfield_len(self):
1437         try: self.__field_len
1438         except:
1439             self.__field_len=UINT(**{'sizeinbytes': 1, 'constant': 150})
1440         return self.__field_len.getvalue()
1441 
1442     def __setfield_len(self, value):
1443         if isinstance(value,UINT):
1444             self.__field_len=value
1445         else:
1446             self.__field_len=UINT(value,**{'sizeinbytes': 1, 'constant': 150})
1447 
1448     def __delfield_len(self): del self.__field_len
1449 
1450     len=property(__getfield_len, __setfield_len, __delfield_len, None)
1451 
1452     def __getfield_data(self):
1453         return self.__field_data.getvalue()
1454 
1455     def __setfield_data(self, value):
1456         if isinstance(value,DATA):
1457             self.__field_data=value
1458         else:
1459             self.__field_data=DATA(value,**{'sizeinbytes': 150})
1460 
1461     def __delfield_data(self): del self.__field_data
1462 
1463     data=property(__getfield_data, __setfield_data, __delfield_data, None)
1464 
1465     def __getfield_pad(self):
1466         try: self.__field_pad
1467         except:
1468             self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1469         return self.__field_pad.getvalue()
1470 
1471     def __setfield_pad(self, value):
1472         if isinstance(value,UNKNOWN):
1473             self.__field_pad=value
1474         else:
1475             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 21})
1476 
1477     def __delfield_pad(self): del self.__field_pad
1478 
1479     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1480 
1481     def iscontainer(self):
1482         return True
1483 
1484     def containerelements(self):
1485         yield ('header', self.__field_header, None)
1486         yield ('word', self.__field_word, None)
1487         yield ('len', self.__field_len, None)
1488         yield ('data', self.__field_data, None)
1489         yield ('pad', self.__field_pad, None)
1490 
1491 
1492 
1493 
1494 class sanyomediaresponse(BaseProtogenClass):
1495     __fields=['header', 'UNKNOWN']
1496 
1497     def __init__(self, *args, **kwargs):
1498         dict={}
1499         # What was supplied to this function
1500         dict.update(kwargs)
1501         # Parent constructor
1502         super(sanyomediaresponse,self).__init__(**dict)
1503         if self.__class__ is sanyomediaresponse:
1504             self._update(args,dict)
1505 
1506 
1507     def getfields(self):
1508         return self.__fields
1509 
1510 
1511     def _update(self, args, kwargs):
1512         super(sanyomediaresponse,self)._update(args,kwargs)
1513         keys=kwargs.keys()
1514         for key in keys:
1515             if key in self.__fields:
1516                 setattr(self, key, kwargs[key])
1517                 del kwargs[key]
1518         # Were any unrecognized kwargs passed in?
1519         if __debug__:
1520             self._complainaboutunusedargs(sanyomediaresponse,kwargs)
1521         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1522         # Make all P fields that haven't already been constructed
1523 
1524 
1525     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1526         'Writes this packet to the supplied buffer'
1527         self._bufferstartoffset=buf.getcurrentoffset()
1528         self.__field_header.writetobuffer(buf)
1529         self.__field_UNKNOWN.writetobuffer(buf)
1530         self._bufferendoffset=buf.getcurrentoffset()
1531         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1532 
1533 
1534     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1535         'Reads this packet from the supplied buffer'
1536         self._bufferstartoffset=buf.getcurrentoffset()
1537         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1538         self.__field_header=sanyomediaheader()
1539         self.__field_header.readfrombuffer(buf)
1540         self.__field_UNKNOWN=UNKNOWN()
1541         self.__field_UNKNOWN.readfrombuffer(buf)
1542         self._bufferendoffset=buf.getcurrentoffset()
1543 
1544 
1545     def __getfield_header(self):
1546         return self.__field_header.getvalue()
1547 
1548     def __setfield_header(self, value):
1549         if isinstance(value,sanyomediaheader):
1550             self.__field_header=value
1551         else:
1552             self.__field_header=sanyomediaheader(value,)
1553 
1554     def __delfield_header(self): del self.__field_header
1555 
1556     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1557 
1558     def __getfield_UNKNOWN(self):
1559         return self.__field_UNKNOWN.getvalue()
1560 
1561     def __setfield_UNKNOWN(self, value):
1562         if isinstance(value,UNKNOWN):
1563             self.__field_UNKNOWN=value
1564         else:
1565             self.__field_UNKNOWN=UNKNOWN(value,)
1566 
1567     def __delfield_UNKNOWN(self): del self.__field_UNKNOWN
1568 
1569     UNKNOWN=property(__getfield_UNKNOWN, __setfield_UNKNOWN, __delfield_UNKNOWN, None)
1570 
1571     def iscontainer(self):
1572         return True
1573 
1574     def containerelements(self):
1575         yield ('header', self.__field_header, None)
1576         yield ('UNKNOWN', self.__field_UNKNOWN, None)
1577 
1578 
1579 
1580 
1581 class sanyosendfilename(BaseProtogenClass):
1582     __fields=['header', 'payloadsize', 'filename', 'pad']
1583 
1584     def __init__(self, *args, **kwargs):
1585         dict={}
1586         # What was supplied to this function
1587         dict.update(kwargs)
1588         # Parent constructor
1589         super(sanyosendfilename,self).__init__(**dict)
1590         if self.__class__ is sanyosendfilename:
1591             self._update(args,dict)
1592 
1593 
1594     def getfields(self):
1595         return self.__fields
1596 
1597 
1598     def _update(self, args, kwargs):
1599         super(sanyosendfilename,self)._update(args,kwargs)
1600         keys=kwargs.keys()
1601         for key in keys:
1602             if key in self.__fields:
1603                 setattr(self, key, kwargs[key])
1604                 del kwargs[key]
1605         # Were any unrecognized kwargs passed in?
1606         if __debug__:
1607             self._complainaboutunusedargs(sanyosendfilename,kwargs)
1608         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1609         # Make all P fields that haven't already been constructed
1610 
1611 
1612     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1613         'Writes this packet to the supplied buffer'
1614         self._bufferstartoffset=buf.getcurrentoffset()
1615         try: self.__field_header
1616         except:
1617             self.__field_header=sanyomediaheader(**{'command': 0xffa1, 'pad': 0, 'faset': 0x05})
1618         self.__field_header.writetobuffer(buf)
1619         try: self.__field_payloadsize
1620         except:
1621             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1622         self.__field_payloadsize.writetobuffer(buf)
1623         try: self.__field_filename
1624         except:
1625             self.__field_filename=USTRING(**{'sizeinbytes': 150, 'default': ""})
1626         self.__field_filename.writetobuffer(buf)
1627         try: self.__field_pad
1628         except:
1629             self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1630         self.__field_pad.writetobuffer(buf)
1631         self._bufferendoffset=buf.getcurrentoffset()
1632         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1633 
1634 
1635     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1636         'Reads this packet from the supplied buffer'
1637         self._bufferstartoffset=buf.getcurrentoffset()
1638         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1639         self.__field_header=sanyomediaheader(**{'command': 0xffa1, 'pad': 0, 'faset': 0x05})
1640         self.__field_header.readfrombuffer(buf)
1641         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1642         self.__field_payloadsize.readfrombuffer(buf)
1643         self.__field_filename=USTRING(**{'sizeinbytes': 150, 'default': ""})
1644         self.__field_filename.readfrombuffer(buf)
1645         self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1646         self.__field_pad.readfrombuffer(buf)
1647         self._bufferendoffset=buf.getcurrentoffset()
1648 
1649 
1650     def __getfield_header(self):
1651         try: self.__field_header
1652         except:
1653             self.__field_header=sanyomediaheader(**{'command': 0xffa1, 'pad': 0, 'faset': 0x05})
1654         return self.__field_header.getvalue()
1655 
1656     def __setfield_header(self, value):
1657         if isinstance(value,sanyomediaheader):
1658             self.__field_header=value
1659         else:
1660             self.__field_header=sanyomediaheader(value,**{'command': 0xffa1, 'pad': 0, 'faset': 0x05})
1661 
1662     def __delfield_header(self): del self.__field_header
1663 
1664     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1665 
1666     def __getfield_payloadsize(self):
1667         try: self.__field_payloadsize
1668         except:
1669             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1670         return self.__field_payloadsize.getvalue()
1671 
1672     def __setfield_payloadsize(self, value):
1673         if isinstance(value,UINT):
1674             self.__field_payloadsize=value
1675         else:
1676             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x96})
1677 
1678     def __delfield_payloadsize(self): del self.__field_payloadsize
1679 
1680     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
1681 
1682     def __getfield_filename(self):
1683         try: self.__field_filename
1684         except:
1685             self.__field_filename=USTRING(**{'sizeinbytes': 150, 'default': ""})
1686         return self.__field_filename.getvalue()
1687 
1688     def __setfield_filename(self, value):
1689         if isinstance(value,USTRING):
1690             self.__field_filename=value
1691         else:
1692             self.__field_filename=USTRING(value,**{'sizeinbytes': 150, 'default': ""})
1693 
1694     def __delfield_filename(self): del self.__field_filename
1695 
1696     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
1697 
1698     def __getfield_pad(self):
1699         try: self.__field_pad
1700         except:
1701             self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1702         return self.__field_pad.getvalue()
1703 
1704     def __setfield_pad(self, value):
1705         if isinstance(value,UNKNOWN):
1706             self.__field_pad=value
1707         else:
1708             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 21})
1709 
1710     def __delfield_pad(self): del self.__field_pad
1711 
1712     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1713 
1714     def iscontainer(self):
1715         return True
1716 
1717     def containerelements(self):
1718         yield ('header', self.__field_header, None)
1719         yield ('payloadsize', self.__field_payloadsize, None)
1720         yield ('filename', self.__field_filename, None)
1721         yield ('pad', self.__field_pad, None)
1722 
1723 
1724 
1725 
1726 class sanyosendfilesize(BaseProtogenClass):
1727     __fields=['header', 'payloadsize', 'pad1', 'filesize', 'pad2']
1728 
1729     def __init__(self, *args, **kwargs):
1730         dict={}
1731         # What was supplied to this function
1732         dict.update(kwargs)
1733         # Parent constructor
1734         super(sanyosendfilesize,self).__init__(**dict)
1735         if self.__class__ is sanyosendfilesize:
1736             self._update(args,dict)
1737 
1738 
1739     def getfields(self):
1740         return self.__fields
1741 
1742 
1743     def _update(self, args, kwargs):
1744         super(sanyosendfilesize,self)._update(args,kwargs)
1745         keys=kwargs.keys()
1746         for key in keys:
1747             if key in self.__fields:
1748                 setattr(self, key, kwargs[key])
1749                 del kwargs[key]
1750         # Were any unrecognized kwargs passed in?
1751         if __debug__:
1752             self._complainaboutunusedargs(sanyosendfilesize,kwargs)
1753         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1754         # Make all P fields that haven't already been constructed
1755 
1756 
1757     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1758         'Writes this packet to the supplied buffer'
1759         self._bufferstartoffset=buf.getcurrentoffset()
1760         try: self.__field_header
1761         except:
1762             self.__field_header=sanyomediaheader(**{'command': 0xffc1, 'pad': 0, 'faset': 0x05})
1763         self.__field_header.writetobuffer(buf)
1764         try: self.__field_payloadsize
1765         except:
1766             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1767         self.__field_payloadsize.writetobuffer(buf)
1768         try: self.__field_pad1
1769         except:
1770             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
1771         self.__field_pad1.writetobuffer(buf)
1772         self.__field_filesize.writetobuffer(buf)
1773         try: self.__field_pad2
1774         except:
1775             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 168})
1776         self.__field_pad2.writetobuffer(buf)
1777         self._bufferendoffset=buf.getcurrentoffset()
1778         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1779 
1780 
1781     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1782         'Reads this packet from the supplied buffer'
1783         self._bufferstartoffset=buf.getcurrentoffset()
1784         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1785         self.__field_header=sanyomediaheader(**{'command': 0xffc1, 'pad': 0, 'faset': 0x05})
1786         self.__field_header.readfrombuffer(buf)
1787         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1788         self.__field_payloadsize.readfrombuffer(buf)
1789         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
1790         self.__field_pad1.readfrombuffer(buf)
1791         self.__field_filesize=UINT(**{'sizeinbytes': 2})
1792         self.__field_filesize.readfrombuffer(buf)
1793         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 168})
1794         self.__field_pad2.readfrombuffer(buf)
1795         self._bufferendoffset=buf.getcurrentoffset()
1796 
1797 
1798     def __getfield_header(self):
1799         try: self.__field_header
1800         except:
1801             self.__field_header=sanyomediaheader(**{'command': 0xffc1, 'pad': 0, 'faset': 0x05})
1802         return self.__field_header.getvalue()
1803 
1804     def __setfield_header(self, value):
1805         if isinstance(value,sanyomediaheader):
1806             self.__field_header=value
1807         else:
1808             self.__field_header=sanyomediaheader(value,**{'command': 0xffc1, 'pad': 0, 'faset': 0x05})
1809 
1810     def __delfield_header(self): del self.__field_header
1811 
1812     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1813 
1814     def __getfield_payloadsize(self):
1815         try: self.__field_payloadsize
1816         except:
1817             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1818         return self.__field_payloadsize.getvalue()
1819 
1820     def __setfield_payloadsize(self, value):
1821         if isinstance(value,UINT):
1822             self.__field_payloadsize=value
1823         else:
1824             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x96})
1825 
1826     def __delfield_payloadsize(self): del self.__field_payloadsize
1827 
1828     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
1829 
1830     def __getfield_pad1(self):
1831         try: self.__field_pad1
1832         except:
1833             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
1834         return self.__field_pad1.getvalue()
1835 
1836     def __setfield_pad1(self, value):
1837         if isinstance(value,UNKNOWN):
1838             self.__field_pad1=value
1839         else:
1840             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
1841 
1842     def __delfield_pad1(self): del self.__field_pad1
1843 
1844     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1845 
1846     def __getfield_filesize(self):
1847         return self.__field_filesize.getvalue()
1848 
1849     def __setfield_filesize(self, value):
1850         if isinstance(value,UINT):
1851             self.__field_filesize=value
1852         else:
1853             self.__field_filesize=UINT(value,**{'sizeinbytes': 2})
1854 
1855     def __delfield_filesize(self): del self.__field_filesize
1856 
1857     filesize=property(__getfield_filesize, __setfield_filesize, __delfield_filesize, None)
1858 
1859     def __getfield_pad2(self):
1860         try: self.__field_pad2
1861         except:
1862             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 168})
1863         return self.__field_pad2.getvalue()
1864 
1865     def __setfield_pad2(self, value):
1866         if isinstance(value,UNKNOWN):
1867             self.__field_pad2=value
1868         else:
1869             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 168})
1870 
1871     def __delfield_pad2(self): del self.__field_pad2
1872 
1873     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1874 
1875     def iscontainer(self):
1876         return True
1877 
1878     def containerelements(self):
1879         yield ('header', self.__field_header, None)
1880         yield ('payloadsize', self.__field_payloadsize, None)
1881         yield ('pad1', self.__field_pad1, None)
1882         yield ('filesize', self.__field_filesize, None)
1883         yield ('pad2', self.__field_pad2, None)
1884 
1885 
1886 
1887 
1888 class sanyosendfilefragment(BaseProtogenClass):
1889     __fields=['header', 'payloadsize', 'data', 'pad']
1890 
1891     def __init__(self, *args, **kwargs):
1892         dict={}
1893         # What was supplied to this function
1894         dict.update(kwargs)
1895         # Parent constructor
1896         super(sanyosendfilefragment,self).__init__(**dict)
1897         if self.__class__ is sanyosendfilefragment:
1898             self._update(args,dict)
1899 
1900 
1901     def getfields(self):
1902         return self.__fields
1903 
1904 
1905     def _update(self, args, kwargs):
1906         super(sanyosendfilefragment,self)._update(args,kwargs)
1907         keys=kwargs.keys()
1908         for key in keys:
1909             if key in self.__fields:
1910                 setattr(self, key, kwargs[key])
1911                 del kwargs[key]
1912         # Were any unrecognized kwargs passed in?
1913         if __debug__:
1914             self._complainaboutunusedargs(sanyosendfilefragment,kwargs)
1915         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1916         # Make all P fields that haven't already been constructed
1917 
1918 
1919     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1920         'Writes this packet to the supplied buffer'
1921         self._bufferstartoffset=buf.getcurrentoffset()
1922         try: self.__field_header
1923         except:
1924             self.__field_header=sanyomediaheader(**{'pad': 0, 'faset': 0x05})
1925         self.__field_header.writetobuffer(buf)
1926         try: self.__field_payloadsize
1927         except:
1928             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1929         self.__field_payloadsize.writetobuffer(buf)
1930         self.__field_data.writetobuffer(buf)
1931         try: self.__field_pad
1932         except:
1933             self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1934         self.__field_pad.writetobuffer(buf)
1935         self._bufferendoffset=buf.getcurrentoffset()
1936         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1937 
1938 
1939     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1940         'Reads this packet from the supplied buffer'
1941         self._bufferstartoffset=buf.getcurrentoffset()
1942         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1943         self.__field_header=sanyomediaheader(**{'pad': 0, 'faset': 0x05})
1944         self.__field_header.readfrombuffer(buf)
1945         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1946         self.__field_payloadsize.readfrombuffer(buf)
1947         self.__field_data=DATA(**{'sizeinbytes': 150})
1948         self.__field_data.readfrombuffer(buf)
1949         self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
1950         self.__field_pad.readfrombuffer(buf)
1951         self._bufferendoffset=buf.getcurrentoffset()
1952 
1953 
1954     def __getfield_header(self):
1955         try: self.__field_header
1956         except:
1957             self.__field_header=sanyomediaheader(**{'pad': 0, 'faset': 0x05})
1958         return self.__field_header.getvalue()
1959 
1960     def __setfield_header(self, value):
1961         if isinstance(value,sanyomediaheader):
1962             self.__field_header=value
1963         else:
1964             self.__field_header=sanyomediaheader(value,**{'pad': 0, 'faset': 0x05})
1965 
1966     def __delfield_header(self): del self.__field_header
1967 
1968     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1969 
1970     def __getfield_payloadsize(self):
1971         try: self.__field_payloadsize
1972         except:
1973             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
1974         return self.__field_payloadsize.getvalue()
1975 
1976     def __setfield_payloadsize(self, value):
1977         if isinstance(value,UINT):
1978             self.__field_payloadsize=value
1979         else:
1980             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x96})
1981 
1982     def __delfield_payloadsize(self): del self.__field_payloadsize
1983 
1984     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
1985 
1986     def __getfield_data(self):
1987         return self.__field_data.getvalue()
1988 
1989     def __setfield_data(self, value):
1990         if isinstance(value,DATA):
1991             self.__field_data=value
1992         else:
1993             self.__field_data=DATA(value,**{'sizeinbytes': 150})
1994 
1995     def __delfield_data(self): del self.__field_data
1996 
1997     data=property(__getfield_data, __setfield_data, __delfield_data, None)
1998 
1999     def __getfield_pad(self):
2000         try: self.__field_pad
2001         except:
2002             self.__field_pad=UNKNOWN(**{'sizeinbytes': 21})
2003         return self.__field_pad.getvalue()
2004 
2005     def __setfield_pad(self, value):
2006         if isinstance(value,UNKNOWN):
2007             self.__field_pad=value
2008         else:
2009             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 21})
2010 
2011     def __delfield_pad(self): del self.__field_pad
2012 
2013     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2014 
2015     def iscontainer(self):
2016         return True
2017 
2018     def containerelements(self):
2019         yield ('header', self.__field_header, None)
2020         yield ('payloadsize', self.__field_payloadsize, None)
2021         yield ('data', self.__field_data, None)
2022         yield ('pad', self.__field_pad, None)
2023 
2024 
2025 
2026 
2027 class sanyosendfileterminator(BaseProtogenClass):
2028     __fields=['header', 'payloadsize', 'pad']
2029 
2030     def __init__(self, *args, **kwargs):
2031         dict={}
2032         # What was supplied to this function
2033         dict.update(kwargs)
2034         # Parent constructor
2035         super(sanyosendfileterminator,self).__init__(**dict)
2036         if self.__class__ is sanyosendfileterminator:
2037             self._update(args,dict)
2038 
2039 
2040     def getfields(self):
2041         return self.__fields
2042 
2043 
2044     def _update(self, args, kwargs):
2045         super(sanyosendfileterminator,self)._update(args,kwargs)
2046         keys=kwargs.keys()
2047         for key in keys:
2048             if key in self.__fields:
2049                 setattr(self, key, kwargs[key])
2050                 del kwargs[key]
2051         # Were any unrecognized kwargs passed in?
2052         if __debug__:
2053             self._complainaboutunusedargs(sanyosendfileterminator,kwargs)
2054         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2055         # Make all P fields that haven't already been constructed
2056 
2057 
2058     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2059         'Writes this packet to the supplied buffer'
2060         self._bufferstartoffset=buf.getcurrentoffset()
2061         try: self.__field_header
2062         except:
2063             self.__field_header=sanyomediaheader(**{'command': 0xffe1, 'pad': 0, 'faset': 0x05})
2064         self.__field_header.writetobuffer(buf)
2065         try: self.__field_payloadsize
2066         except:
2067             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
2068         self.__field_payloadsize.writetobuffer(buf)
2069         try: self.__field_pad
2070         except:
2071             self.__field_pad=UNKNOWN(**{'sizeinbytes': 171})
2072         self.__field_pad.writetobuffer(buf)
2073         self._bufferendoffset=buf.getcurrentoffset()
2074         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2075 
2076 
2077     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2078         'Reads this packet from the supplied buffer'
2079         self._bufferstartoffset=buf.getcurrentoffset()
2080         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2081         self.__field_header=sanyomediaheader(**{'command': 0xffe1, 'pad': 0, 'faset': 0x05})
2082         self.__field_header.readfrombuffer(buf)
2083         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
2084         self.__field_payloadsize.readfrombuffer(buf)
2085         self.__field_pad=UNKNOWN(**{'sizeinbytes': 171})
2086         self.__field_pad.readfrombuffer(buf)
2087         self._bufferendoffset=buf.getcurrentoffset()
2088 
2089 
2090     def __getfield_header(self):
2091         try: self.__field_header
2092         except:
2093             self.__field_header=sanyomediaheader(**{'command': 0xffe1, 'pad': 0, 'faset': 0x05})
2094         return self.__field_header.getvalue()
2095 
2096     def __setfield_header(self, value):
2097         if isinstance(value,sanyomediaheader):
2098             self.__field_header=value
2099         else:
2100             self.__field_header=sanyomediaheader(value,**{'command': 0xffe1, 'pad': 0, 'faset': 0x05})
2101 
2102     def __delfield_header(self): del self.__field_header
2103 
2104     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2105 
2106     def __getfield_payloadsize(self):
2107         try: self.__field_payloadsize
2108         except:
2109             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x96})
2110         return self.__field_payloadsize.getvalue()
2111 
2112     def __setfield_payloadsize(self, value):
2113         if isinstance(value,UINT):
2114             self.__field_payloadsize=value
2115         else:
2116             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x96})
2117 
2118     def __delfield_payloadsize(self): del self.__field_payloadsize
2119 
2120     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
2121 
2122     def __getfield_pad(self):
2123         try: self.__field_pad
2124         except:
2125             self.__field_pad=UNKNOWN(**{'sizeinbytes': 171})
2126         return self.__field_pad.getvalue()
2127 
2128     def __setfield_pad(self, value):
2129         if isinstance(value,UNKNOWN):
2130             self.__field_pad=value
2131         else:
2132             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 171})
2133 
2134     def __delfield_pad(self): del self.__field_pad
2135 
2136     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2137 
2138     def iscontainer(self):
2139         return True
2140 
2141     def containerelements(self):
2142         yield ('header', self.__field_header, None)
2143         yield ('payloadsize', self.__field_payloadsize, None)
2144         yield ('pad', self.__field_pad, None)
2145 
2146 
2147 
2148 
2149 class sanyosendfileresponse(BaseProtogenClass):
2150     __fields=['header', 'payloadsize', 'pad']
2151 
2152     def __init__(self, *args, **kwargs):
2153         dict={}
2154         # What was supplied to this function
2155         dict.update(kwargs)
2156         # Parent constructor
2157         super(sanyosendfileresponse,self).__init__(**dict)
2158         if self.__class__ is sanyosendfileresponse:
2159             self._update(args,dict)
2160 
2161 
2162     def getfields(self):
2163         return self.__fields
2164 
2165 
2166     def _update(self, args, kwargs):
2167         super(sanyosendfileresponse,self)._update(args,kwargs)
2168         keys=kwargs.keys()
2169         for key in keys:
2170             if key in self.__fields:
2171                 setattr(self, key, kwargs[key])
2172                 del kwargs[key]
2173         # Were any unrecognized kwargs passed in?
2174         if __debug__:
2175             self._complainaboutunusedargs(sanyosendfileresponse,kwargs)
2176         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2177         # Make all P fields that haven't already been constructed
2178 
2179 
2180     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2181         'Writes this packet to the supplied buffer'
2182         self._bufferstartoffset=buf.getcurrentoffset()
2183         try: self.__field_header
2184         except:
2185             self.__field_header=sanyomediaheader()
2186         self.__field_header.writetobuffer(buf)
2187         self.__field_payloadsize.writetobuffer(buf)
2188         self.__field_pad.writetobuffer(buf)
2189         self._bufferendoffset=buf.getcurrentoffset()
2190         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2191 
2192 
2193     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2194         'Reads this packet from the supplied buffer'
2195         self._bufferstartoffset=buf.getcurrentoffset()
2196         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2197         self.__field_header=sanyomediaheader()
2198         self.__field_header.readfrombuffer(buf)
2199         self.__field_payloadsize=UINT(**{'sizeinbytes': 1})
2200         self.__field_payloadsize.readfrombuffer(buf)
2201         self.__field_pad=UNKNOWN(**{'sizeinbytes': 171})
2202         self.__field_pad.readfrombuffer(buf)
2203         self._bufferendoffset=buf.getcurrentoffset()
2204 
2205 
2206     def __getfield_header(self):
2207         try: self.__field_header
2208         except:
2209             self.__field_header=sanyomediaheader()
2210         return self.__field_header.getvalue()
2211 
2212     def __setfield_header(self, value):
2213         if isinstance(value,sanyomediaheader):
2214             self.__field_header=value
2215         else:
2216             self.__field_header=sanyomediaheader(value,)
2217 
2218     def __delfield_header(self): del self.__field_header
2219 
2220     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2221 
2222     def __getfield_payloadsize(self):
2223         return self.__field_payloadsize.getvalue()
2224 
2225     def __setfield_payloadsize(self, value):
2226         if isinstance(value,UINT):
2227             self.__field_payloadsize=value
2228         else:
2229             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1})
2230 
2231     def __delfield_payloadsize(self): del self.__field_payloadsize
2232 
2233     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
2234 
2235     def __getfield_pad(self):
2236         return self.__field_pad.getvalue()
2237 
2238     def __setfield_pad(self, value):
2239         if isinstance(value,UNKNOWN):
2240             self.__field_pad=value
2241         else:
2242             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 171})
2243 
2244     def __delfield_pad(self): del self.__field_pad
2245 
2246     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2247 
2248     def iscontainer(self):
2249         return True
2250 
2251     def containerelements(self):
2252         yield ('header', self.__field_header, None)
2253         yield ('payloadsize', self.__field_payloadsize, None)
2254         yield ('pad', self.__field_pad, None)
2255 
2256 
2257 
2258 
2259 class sanyomediathingyrequest(BaseProtogenClass):
2260     __fields=['fa', 'faset', 'value']
2261 
2262     def __init__(self, *args, **kwargs):
2263         dict={}
2264         # What was supplied to this function
2265         dict.update(kwargs)
2266         # Parent constructor
2267         super(sanyomediathingyrequest,self).__init__(**dict)
2268         if self.__class__ is sanyomediathingyrequest:
2269             self._update(args,dict)
2270 
2271 
2272     def getfields(self):
2273         return self.__fields
2274 
2275 
2276     def _update(self, args, kwargs):
2277         super(sanyomediathingyrequest,self)._update(args,kwargs)
2278         keys=kwargs.keys()
2279         for key in keys:
2280             if key in self.__fields:
2281                 setattr(self, key, kwargs[key])
2282                 del kwargs[key]
2283         # Were any unrecognized kwargs passed in?
2284         if __debug__:
2285             self._complainaboutunusedargs(sanyomediathingyrequest,kwargs)
2286         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2287         # Make all P fields that haven't already been constructed
2288 
2289 
2290     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2291         'Writes this packet to the supplied buffer'
2292         self._bufferstartoffset=buf.getcurrentoffset()
2293         try: self.__field_fa
2294         except:
2295             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
2296         self.__field_fa.writetobuffer(buf)
2297         self.__field_faset.writetobuffer(buf)
2298         try: self.__field_value
2299         except:
2300             self.__field_value=UINT(**{'sizeinbytes': 2, 'default': 0x0})
2301         self.__field_value.writetobuffer(buf)
2302         self._bufferendoffset=buf.getcurrentoffset()
2303         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2304 
2305 
2306     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2307         'Reads this packet from the supplied buffer'
2308         self._bufferstartoffset=buf.getcurrentoffset()
2309         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2310         self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
2311         self.__field_fa.readfrombuffer(buf)
2312         self.__field_faset=UINT(**{'sizeinbytes': 1})
2313         self.__field_faset.readfrombuffer(buf)
2314         self.__field_value=UINT(**{'sizeinbytes': 2, 'default': 0x0})
2315         self.__field_value.readfrombuffer(buf)
2316         self._bufferendoffset=buf.getcurrentoffset()
2317 
2318 
2319     def __getfield_fa(self):
2320         try: self.__field_fa
2321         except:
2322             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
2323         return self.__field_fa.getvalue()
2324 
2325     def __setfield_fa(self, value):
2326         if isinstance(value,UINT):
2327             self.__field_fa=value
2328         else:
2329             self.__field_fa=UINT(value,**{'sizeinbytes': 2, 'constant': 0xfa})
2330 
2331     def __delfield_fa(self): del self.__field_fa
2332 
2333     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
2334 
2335     def __getfield_faset(self):
2336         return self.__field_faset.getvalue()
2337 
2338     def __setfield_faset(self, value):
2339         if isinstance(value,UINT):
2340             self.__field_faset=value
2341         else:
2342             self.__field_faset=UINT(value,**{'sizeinbytes': 1})
2343 
2344     def __delfield_faset(self): del self.__field_faset
2345 
2346     faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None)
2347 
2348     def __getfield_value(self):
2349         try: self.__field_value
2350         except:
2351             self.__field_value=UINT(**{'sizeinbytes': 2, 'default': 0x0})
2352         return self.__field_value.getvalue()
2353 
2354     def __setfield_value(self, value):
2355         if isinstance(value,UINT):
2356             self.__field_value=value
2357         else:
2358             self.__field_value=UINT(value,**{'sizeinbytes': 2, 'default': 0x0})
2359 
2360     def __delfield_value(self): del self.__field_value
2361 
2362     value=property(__getfield_value, __setfield_value, __delfield_value, None)
2363 
2364     def iscontainer(self):
2365         return True
2366 
2367     def containerelements(self):
2368         yield ('fa', self.__field_fa, None)
2369         yield ('faset', self.__field_faset, None)
2370         yield ('value', self.__field_value, None)
2371 
2372 
2373 
2374 
2375 class sanyomediathingyresponse(BaseProtogenClass):
2376     __fields=['fa', 'faset', 'value']
2377 
2378     def __init__(self, *args, **kwargs):
2379         dict={}
2380         # What was supplied to this function
2381         dict.update(kwargs)
2382         # Parent constructor
2383         super(sanyomediathingyresponse,self).__init__(**dict)
2384         if self.__class__ is sanyomediathingyresponse:
2385             self._update(args,dict)
2386 
2387 
2388     def getfields(self):
2389         return self.__fields
2390 
2391 
2392     def _update(self, args, kwargs):
2393         super(sanyomediathingyresponse,self)._update(args,kwargs)
2394         keys=kwargs.keys()
2395         for key in keys:
2396             if key in self.__fields:
2397                 setattr(self, key, kwargs[key])
2398                 del kwargs[key]
2399         # Were any unrecognized kwargs passed in?
2400         if __debug__:
2401             self._complainaboutunusedargs(sanyomediathingyresponse,kwargs)
2402         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2403         # Make all P fields that haven't already been constructed
2404 
2405 
2406     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2407         'Writes this packet to the supplied buffer'
2408         self._bufferstartoffset=buf.getcurrentoffset()
2409         self.__field_fa.writetobuffer(buf)
2410         self.__field_faset.writetobuffer(buf)
2411         self.__field_value.writetobuffer(buf)
2412         self._bufferendoffset=buf.getcurrentoffset()
2413         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2414 
2415 
2416     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2417         'Reads this packet from the supplied buffer'
2418         self._bufferstartoffset=buf.getcurrentoffset()
2419         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2420         self.__field_fa=UINT(**{'sizeinbytes': 2})
2421         self.__field_fa.readfrombuffer(buf)
2422         self.__field_faset=UINT(**{'sizeinbytes': 1})
2423         self.__field_faset.readfrombuffer(buf)
2424         self.__field_value=UINT(**{'sizeinbytes': 2})
2425         self.__field_value.readfrombuffer(buf)
2426         self._bufferendoffset=buf.getcurrentoffset()
2427 
2428 
2429     def __getfield_fa(self):
2430         return self.__field_fa.getvalue()
2431 
2432     def __setfield_fa(self, value):
2433         if isinstance(value,UINT):
2434             self.__field_fa=value
2435         else:
2436             self.__field_fa=UINT(value,**{'sizeinbytes': 2})
2437 
2438     def __delfield_fa(self): del self.__field_fa
2439 
2440     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
2441 
2442     def __getfield_faset(self):
2443         return self.__field_faset.getvalue()
2444 
2445     def __setfield_faset(self, value):
2446         if isinstance(value,UINT):
2447             self.__field_faset=value
2448         else:
2449             self.__field_faset=UINT(value,**{'sizeinbytes': 1})
2450 
2451     def __delfield_faset(self): del self.__field_faset
2452 
2453     faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None)
2454 
2455     def __getfield_value(self):
2456         return self.__field_value.getvalue()
2457 
2458     def __setfield_value(self, value):
2459         if isinstance(value,UINT):
2460             self.__field_value=value
2461         else:
2462             self.__field_value=UINT(value,**{'sizeinbytes': 2})
2463 
2464     def __delfield_value(self): del self.__field_value
2465 
2466     value=property(__getfield_value, __setfield_value, __delfield_value, None)
2467 
2468     def iscontainer(self):
2469         return True
2470 
2471     def containerelements(self):
2472         yield ('fa', self.__field_fa, None)
2473         yield ('faset', self.__field_faset, None)
2474         yield ('value', self.__field_value, None)
2475 
2476 
2477 
2478 
2479