PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data used in Brew Protocol"""
0004 
0005 from prototypes import *
0006 
0007 # We use LSB for all integer like fields
0008 UINT=UINTlsb
0009 BOOL=BOOLlsb
0010 
0011 new_fileopen_mode_read=0
0012 new_fileopen_mode_write=0x41
0013 new_fileopen_flag_existing=0
0014 new_fileopen_flag_create=1
0015 
0016 import com_brew
0017 
0018 DEFAULT_PHONE_ENCODING='ascii'
0019 PHONE_ENCODING=DEFAULT_PHONE_ENCODING
0020 
0021 # These parameters only work with BREW2 at the moment.
0022 # Note about read block size:
0023 #  - Largest successful read size: 1KB
0024 #  - The LG VX-8700 returns 1KB of data if req.bytes >= 1KB.
0025 #  - If all phones behave in this way it would be safe to change the default read size to 1KB.
0026 BREW_READ_SIZE=0xEB
0027 
0028 # Note about write block size:
0029 #  - Largest successful write size: 7.9kB
0030 #  - Too large a write block will cause a timeout error.
0031 BREW_WRITE_SIZE=0xEA
0032 
0033 class requestheader(BaseProtogenClass):
0034     "The bit in front on all Brew request packets"
0035     __fields=['commandmode', 'command']
0036 
0037     def __init__(self, *args, **kwargs):
0038         dict={}
0039         # What was supplied to this function
0040         dict.update(kwargs)
0041         # Parent constructor
0042         super(requestheader,self).__init__(**dict)
0043         if self.__class__ is requestheader:
0044             self._update(args,dict)
0045 
0046 
0047     def getfields(self):
0048         return self.__fields
0049 
0050 
0051     def _update(self, args, kwargs):
0052         super(requestheader,self)._update(args,kwargs)
0053         keys=kwargs.keys()
0054         for key in keys:
0055             if key in self.__fields:
0056                 setattr(self, key, kwargs[key])
0057                 del kwargs[key]
0058         # Were any unrecognized kwargs passed in?
0059         if __debug__:
0060             self._complainaboutunusedargs(requestheader,kwargs)
0061         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0062         # Make all P fields that haven't already been constructed
0063 
0064 
0065     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0066         'Writes this packet to the supplied buffer'
0067         self._bufferstartoffset=buf.getcurrentoffset()
0068         try: self.__field_commandmode
0069         except:
0070             self.__field_commandmode=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0071         self.__field_commandmode.writetobuffer(buf)
0072         self.__field_command.writetobuffer(buf)
0073         self._bufferendoffset=buf.getcurrentoffset()
0074         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0075 
0076 
0077     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0078         'Reads this packet from the supplied buffer'
0079         self._bufferstartoffset=buf.getcurrentoffset()
0080         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0081         self.__field_commandmode=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0082         self.__field_commandmode.readfrombuffer(buf)
0083         self.__field_command=UINT(**{'sizeinbytes': 1})
0084         self.__field_command.readfrombuffer(buf)
0085         self._bufferendoffset=buf.getcurrentoffset()
0086 
0087 
0088     def __getfield_commandmode(self):
0089         try: self.__field_commandmode
0090         except:
0091             self.__field_commandmode=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0092         return self.__field_commandmode.getvalue()
0093 
0094     def __setfield_commandmode(self, value):
0095         if isinstance(value,UINT):
0096             self.__field_commandmode=value
0097         else:
0098             self.__field_commandmode=UINT(value,**{'sizeinbytes': 1, 'constant': 0x59})
0099 
0100     def __delfield_commandmode(self): del self.__field_commandmode
0101 
0102     commandmode=property(__getfield_commandmode, __setfield_commandmode, __delfield_commandmode, None)
0103 
0104     def __getfield_command(self):
0105         return self.__field_command.getvalue()
0106 
0107     def __setfield_command(self, value):
0108         if isinstance(value,UINT):
0109             self.__field_command=value
0110         else:
0111             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0112 
0113     def __delfield_command(self): del self.__field_command
0114 
0115     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0116 
0117     def iscontainer(self):
0118         return True
0119 
0120     def containerelements(self):
0121         yield ('commandmode', self.__field_commandmode, None)
0122         yield ('command', self.__field_command, None)
0123 
0124 
0125 
0126 
0127 class responseheader(BaseProtogenClass):
0128     "The bit in front on all Brew response packets"
0129     __fields=['commandmode', 'command', 'errorcode']
0130 
0131     def __init__(self, *args, **kwargs):
0132         dict={}
0133         # What was supplied to this function
0134         dict.update(kwargs)
0135         # Parent constructor
0136         super(responseheader,self).__init__(**dict)
0137         if self.__class__ is responseheader:
0138             self._update(args,dict)
0139 
0140 
0141     def getfields(self):
0142         return self.__fields
0143 
0144 
0145     def _update(self, args, kwargs):
0146         super(responseheader,self)._update(args,kwargs)
0147         keys=kwargs.keys()
0148         for key in keys:
0149             if key in self.__fields:
0150                 setattr(self, key, kwargs[key])
0151                 del kwargs[key]
0152         # Were any unrecognized kwargs passed in?
0153         if __debug__:
0154             self._complainaboutunusedargs(responseheader,kwargs)
0155         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0156         # Make all P fields that haven't already been constructed
0157 
0158 
0159     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0160         'Writes this packet to the supplied buffer'
0161         self._bufferstartoffset=buf.getcurrentoffset()
0162         self.__field_commandmode.writetobuffer(buf)
0163         self.__field_command.writetobuffer(buf)
0164         self.__field_errorcode.writetobuffer(buf)
0165         self._bufferendoffset=buf.getcurrentoffset()
0166         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0167 
0168 
0169     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0170         'Reads this packet from the supplied buffer'
0171         self._bufferstartoffset=buf.getcurrentoffset()
0172         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0173         self.__field_commandmode=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0174         self.__field_commandmode.readfrombuffer(buf)
0175         self.__field_command=UINT(**{'sizeinbytes': 1})
0176         self.__field_command.readfrombuffer(buf)
0177         self.__field_errorcode=UINT(**{'sizeinbytes': 1})
0178         self.__field_errorcode.readfrombuffer(buf)
0179         self._bufferendoffset=buf.getcurrentoffset()
0180 
0181 
0182     def __getfield_commandmode(self):
0183         return self.__field_commandmode.getvalue()
0184 
0185     def __setfield_commandmode(self, value):
0186         if isinstance(value,UINT):
0187             self.__field_commandmode=value
0188         else:
0189             self.__field_commandmode=UINT(value,**{'sizeinbytes': 1, 'constant': 0x59})
0190 
0191     def __delfield_commandmode(self): del self.__field_commandmode
0192 
0193     commandmode=property(__getfield_commandmode, __setfield_commandmode, __delfield_commandmode, None)
0194 
0195     def __getfield_command(self):
0196         return self.__field_command.getvalue()
0197 
0198     def __setfield_command(self, value):
0199         if isinstance(value,UINT):
0200             self.__field_command=value
0201         else:
0202             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0203 
0204     def __delfield_command(self): del self.__field_command
0205 
0206     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0207 
0208     def __getfield_errorcode(self):
0209         return self.__field_errorcode.getvalue()
0210 
0211     def __setfield_errorcode(self, value):
0212         if isinstance(value,UINT):
0213             self.__field_errorcode=value
0214         else:
0215             self.__field_errorcode=UINT(value,**{'sizeinbytes': 1})
0216 
0217     def __delfield_errorcode(self): del self.__field_errorcode
0218 
0219     errorcode=property(__getfield_errorcode, __setfield_errorcode, __delfield_errorcode, None)
0220 
0221     def iscontainer(self):
0222         return True
0223 
0224     def containerelements(self):
0225         yield ('commandmode', self.__field_commandmode, None)
0226         yield ('command', self.__field_command, None)
0227         yield ('errorcode', self.__field_errorcode, None)
0228 
0229 
0230 
0231 
0232 class readfilerequest(BaseProtogenClass):
0233     __fields=['header', 'blocknumber', 'filename']
0234 
0235     def __init__(self, *args, **kwargs):
0236         dict={}
0237         # What was supplied to this function
0238         dict.update(kwargs)
0239         # Parent constructor
0240         super(readfilerequest,self).__init__(**dict)
0241         if self.__class__ is readfilerequest:
0242             self._update(args,dict)
0243 
0244 
0245     def getfields(self):
0246         return self.__fields
0247 
0248 
0249     def _update(self, args, kwargs):
0250         super(readfilerequest,self)._update(args,kwargs)
0251         keys=kwargs.keys()
0252         for key in keys:
0253             if key in self.__fields:
0254                 setattr(self, key, kwargs[key])
0255                 del kwargs[key]
0256         # Were any unrecognized kwargs passed in?
0257         if __debug__:
0258             self._complainaboutunusedargs(readfilerequest,kwargs)
0259         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0260         # Make all P fields that haven't already been constructed
0261 
0262 
0263     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0264         'Writes this packet to the supplied buffer'
0265         self._bufferstartoffset=buf.getcurrentoffset()
0266         try: self.__field_header
0267         except:
0268             self.__field_header=requestheader(**{'command': 0x04})
0269         self.__field_header.writetobuffer(buf)
0270         try: self.__field_blocknumber
0271         except:
0272             self.__field_blocknumber=UINT(**{'sizeinbytes': 1, 'constant': 0})
0273         self.__field_blocknumber.writetobuffer(buf)
0274         self.__field_filename.writetobuffer(buf)
0275         self._bufferendoffset=buf.getcurrentoffset()
0276         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0277 
0278 
0279     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0280         'Reads this packet from the supplied buffer'
0281         self._bufferstartoffset=buf.getcurrentoffset()
0282         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0283         self.__field_header=requestheader(**{'command': 0x04})
0284         self.__field_header.readfrombuffer(buf)
0285         self.__field_blocknumber=UINT(**{'sizeinbytes': 1, 'constant': 0})
0286         self.__field_blocknumber.readfrombuffer(buf)
0287         self.__field_filename=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
0288         self.__field_filename.readfrombuffer(buf)
0289         self._bufferendoffset=buf.getcurrentoffset()
0290 
0291 
0292     def __getfield_header(self):
0293         try: self.__field_header
0294         except:
0295             self.__field_header=requestheader(**{'command': 0x04})
0296         return self.__field_header.getvalue()
0297 
0298     def __setfield_header(self, value):
0299         if isinstance(value,requestheader):
0300             self.__field_header=value
0301         else:
0302             self.__field_header=requestheader(value,**{'command': 0x04})
0303 
0304     def __delfield_header(self): del self.__field_header
0305 
0306     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0307 
0308     def __getfield_blocknumber(self):
0309         try: self.__field_blocknumber
0310         except:
0311             self.__field_blocknumber=UINT(**{'sizeinbytes': 1, 'constant': 0})
0312         return self.__field_blocknumber.getvalue()
0313 
0314     def __setfield_blocknumber(self, value):
0315         if isinstance(value,UINT):
0316             self.__field_blocknumber=value
0317         else:
0318             self.__field_blocknumber=UINT(value,**{'sizeinbytes': 1, 'constant': 0})
0319 
0320     def __delfield_blocknumber(self): del self.__field_blocknumber
0321 
0322     blocknumber=property(__getfield_blocknumber, __setfield_blocknumber, __delfield_blocknumber, None)
0323 
0324     def __getfield_filename(self):
0325         return self.__field_filename.getvalue()
0326 
0327     def __setfield_filename(self, value):
0328         if isinstance(value,USTRING):
0329             self.__field_filename=value
0330         else:
0331             self.__field_filename=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
0332 
0333     def __delfield_filename(self): del self.__field_filename
0334 
0335     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
0336 
0337     def iscontainer(self):
0338         return True
0339 
0340     def containerelements(self):
0341         yield ('header', self.__field_header, None)
0342         yield ('blocknumber', self.__field_blocknumber, None)
0343         yield ('filename', self.__field_filename, None)
0344 
0345 
0346 
0347 
0348 class readfileresponse(BaseProtogenClass):
0349     __fields=['header', 'blockcounter', 'thereismore', 'filesize', 'datasize', 'data']
0350 
0351     def __init__(self, *args, **kwargs):
0352         dict={}
0353         # What was supplied to this function
0354         dict.update(kwargs)
0355         # Parent constructor
0356         super(readfileresponse,self).__init__(**dict)
0357         if self.__class__ is readfileresponse:
0358             self._update(args,dict)
0359 
0360 
0361     def getfields(self):
0362         return self.__fields
0363 
0364 
0365     def _update(self, args, kwargs):
0366         super(readfileresponse,self)._update(args,kwargs)
0367         keys=kwargs.keys()
0368         for key in keys:
0369             if key in self.__fields:
0370                 setattr(self, key, kwargs[key])
0371                 del kwargs[key]
0372         # Were any unrecognized kwargs passed in?
0373         if __debug__:
0374             self._complainaboutunusedargs(readfileresponse,kwargs)
0375         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0376         # Make all P fields that haven't already been constructed
0377 
0378 
0379     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0380         'Writes this packet to the supplied buffer'
0381         self._bufferstartoffset=buf.getcurrentoffset()
0382         self.__field_header.writetobuffer(buf)
0383         self.__field_blockcounter.writetobuffer(buf)
0384         self.__field_thereismore.writetobuffer(buf)
0385         self.__field_filesize.writetobuffer(buf)
0386         self.__field_datasize.writetobuffer(buf)
0387         self.__field_data.writetobuffer(buf)
0388         self._bufferendoffset=buf.getcurrentoffset()
0389         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0390 
0391 
0392     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0393         'Reads this packet from the supplied buffer'
0394         self._bufferstartoffset=buf.getcurrentoffset()
0395         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0396         self.__field_header=responseheader()
0397         self.__field_header.readfrombuffer(buf)
0398         self.__field_blockcounter=UINT(**{'sizeinbytes': 1})
0399         self.__field_blockcounter.readfrombuffer(buf)
0400         self.__field_thereismore=BOOL(**{'sizeinbytes': 1})
0401         self.__field_thereismore.readfrombuffer(buf)
0402         self.__field_filesize=UINT(**{'sizeinbytes': 4})
0403         self.__field_filesize.readfrombuffer(buf)
0404         self.__field_datasize=UINT(**{'sizeinbytes': 2})
0405         self.__field_datasize.readfrombuffer(buf)
0406         self.__field_data=DATA(**{'sizeinbytes': self.datasize})
0407         self.__field_data.readfrombuffer(buf)
0408         self._bufferendoffset=buf.getcurrentoffset()
0409 
0410 
0411     def __getfield_header(self):
0412         return self.__field_header.getvalue()
0413 
0414     def __setfield_header(self, value):
0415         if isinstance(value,responseheader):
0416             self.__field_header=value
0417         else:
0418             self.__field_header=responseheader(value,)
0419 
0420     def __delfield_header(self): del self.__field_header
0421 
0422     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0423 
0424     def __getfield_blockcounter(self):
0425         return self.__field_blockcounter.getvalue()
0426 
0427     def __setfield_blockcounter(self, value):
0428         if isinstance(value,UINT):
0429             self.__field_blockcounter=value
0430         else:
0431             self.__field_blockcounter=UINT(value,**{'sizeinbytes': 1})
0432 
0433     def __delfield_blockcounter(self): del self.__field_blockcounter
0434 
0435     blockcounter=property(__getfield_blockcounter, __setfield_blockcounter, __delfield_blockcounter, None)
0436 
0437     def __getfield_thereismore(self):
0438         return self.__field_thereismore.getvalue()
0439 
0440     def __setfield_thereismore(self, value):
0441         if isinstance(value,BOOL):
0442             self.__field_thereismore=value
0443         else:
0444             self.__field_thereismore=BOOL(value,**{'sizeinbytes': 1})
0445 
0446     def __delfield_thereismore(self): del self.__field_thereismore
0447 
0448     thereismore=property(__getfield_thereismore, __setfield_thereismore, __delfield_thereismore, "true if there is more data available after this block")
0449 
0450     def __getfield_filesize(self):
0451         return self.__field_filesize.getvalue()
0452 
0453     def __setfield_filesize(self, value):
0454         if isinstance(value,UINT):
0455             self.__field_filesize=value
0456         else:
0457             self.__field_filesize=UINT(value,**{'sizeinbytes': 4})
0458 
0459     def __delfield_filesize(self): del self.__field_filesize
0460 
0461     filesize=property(__getfield_filesize, __setfield_filesize, __delfield_filesize, None)
0462 
0463     def __getfield_datasize(self):
0464         return self.__field_datasize.getvalue()
0465 
0466     def __setfield_datasize(self, value):
0467         if isinstance(value,UINT):
0468             self.__field_datasize=value
0469         else:
0470             self.__field_datasize=UINT(value,**{'sizeinbytes': 2})
0471 
0472     def __delfield_datasize(self): del self.__field_datasize
0473 
0474     datasize=property(__getfield_datasize, __setfield_datasize, __delfield_datasize, None)
0475 
0476     def __getfield_data(self):
0477         return self.__field_data.getvalue()
0478 
0479     def __setfield_data(self, value):
0480         if isinstance(value,DATA):
0481             self.__field_data=value
0482         else:
0483             self.__field_data=DATA(value,**{'sizeinbytes': self.datasize})
0484 
0485     def __delfield_data(self): del self.__field_data
0486 
0487     data=property(__getfield_data, __setfield_data, __delfield_data, None)
0488 
0489     def iscontainer(self):
0490         return True
0491 
0492     def containerelements(self):
0493         yield ('header', self.__field_header, None)
0494         yield ('blockcounter', self.__field_blockcounter, None)
0495         yield ('thereismore', self.__field_thereismore, "true if there is more data available after this block")
0496         yield ('filesize', self.__field_filesize, None)
0497         yield ('datasize', self.__field_datasize, None)
0498         yield ('data', self.__field_data, None)
0499 
0500 
0501 
0502 
0503 class readfileblockrequest(BaseProtogenClass):
0504     __fields=['header', 'blockcounter']
0505 
0506     def __init__(self, *args, **kwargs):
0507         dict={}
0508         # What was supplied to this function
0509         dict.update(kwargs)
0510         # Parent constructor
0511         super(readfileblockrequest,self).__init__(**dict)
0512         if self.__class__ is readfileblockrequest:
0513             self._update(args,dict)
0514 
0515 
0516     def getfields(self):
0517         return self.__fields
0518 
0519 
0520     def _update(self, args, kwargs):
0521         super(readfileblockrequest,self)._update(args,kwargs)
0522         keys=kwargs.keys()
0523         for key in keys:
0524             if key in self.__fields:
0525                 setattr(self, key, kwargs[key])
0526                 del kwargs[key]
0527         # Were any unrecognized kwargs passed in?
0528         if __debug__:
0529             self._complainaboutunusedargs(readfileblockrequest,kwargs)
0530         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0531         # Make all P fields that haven't already been constructed
0532 
0533 
0534     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0535         'Writes this packet to the supplied buffer'
0536         self._bufferstartoffset=buf.getcurrentoffset()
0537         try: self.__field_header
0538         except:
0539             self.__field_header=requestheader(**{'command': 0x04})
0540         self.__field_header.writetobuffer(buf)
0541         self.__field_blockcounter.writetobuffer(buf)
0542         self._bufferendoffset=buf.getcurrentoffset()
0543         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0544 
0545 
0546     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0547         'Reads this packet from the supplied buffer'
0548         self._bufferstartoffset=buf.getcurrentoffset()
0549         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0550         self.__field_header=requestheader(**{'command': 0x04})
0551         self.__field_header.readfrombuffer(buf)
0552         self.__field_blockcounter=UINT(**{'sizeinbytes': 1})
0553         self.__field_blockcounter.readfrombuffer(buf)
0554         self._bufferendoffset=buf.getcurrentoffset()
0555 
0556 
0557     def __getfield_header(self):
0558         try: self.__field_header
0559         except:
0560             self.__field_header=requestheader(**{'command': 0x04})
0561         return self.__field_header.getvalue()
0562 
0563     def __setfield_header(self, value):
0564         if isinstance(value,requestheader):
0565             self.__field_header=value
0566         else:
0567             self.__field_header=requestheader(value,**{'command': 0x04})
0568 
0569     def __delfield_header(self): del self.__field_header
0570 
0571     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0572 
0573     def __getfield_blockcounter(self):
0574         return self.__field_blockcounter.getvalue()
0575 
0576     def __setfield_blockcounter(self, value):
0577         if isinstance(value,UINT):
0578             self.__field_blockcounter=value
0579         else:
0580             self.__field_blockcounter=UINT(value,**{'sizeinbytes': 1})
0581 
0582     def __delfield_blockcounter(self): del self.__field_blockcounter
0583 
0584     blockcounter=property(__getfield_blockcounter, __setfield_blockcounter, __delfield_blockcounter, "always greater than zero, increment with each request, loop to 0x01 from 0xff")
0585 
0586     def iscontainer(self):
0587         return True
0588 
0589     def containerelements(self):
0590         yield ('header', self.__field_header, None)
0591         yield ('blockcounter', self.__field_blockcounter, "always greater than zero, increment with each request, loop to 0x01 from 0xff")
0592 
0593 
0594 
0595 
0596 class readfileblockresponse(BaseProtogenClass):
0597     __fields=['header', 'blockcounter', 'thereismore', 'datasize', 'data']
0598 
0599     def __init__(self, *args, **kwargs):
0600         dict={}
0601         # What was supplied to this function
0602         dict.update(kwargs)
0603         # Parent constructor
0604         super(readfileblockresponse,self).__init__(**dict)
0605         if self.__class__ is readfileblockresponse:
0606             self._update(args,dict)
0607 
0608 
0609     def getfields(self):
0610         return self.__fields
0611 
0612 
0613     def _update(self, args, kwargs):
0614         super(readfileblockresponse,self)._update(args,kwargs)
0615         keys=kwargs.keys()
0616         for key in keys:
0617             if key in self.__fields:
0618                 setattr(self, key, kwargs[key])
0619                 del kwargs[key]
0620         # Were any unrecognized kwargs passed in?
0621         if __debug__:
0622             self._complainaboutunusedargs(readfileblockresponse,kwargs)
0623         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0624         # Make all P fields that haven't already been constructed
0625 
0626 
0627     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0628         'Writes this packet to the supplied buffer'
0629         self._bufferstartoffset=buf.getcurrentoffset()
0630         self.__field_header.writetobuffer(buf)
0631         self.__field_blockcounter.writetobuffer(buf)
0632         self.__field_thereismore.writetobuffer(buf)
0633         self.__field_datasize.writetobuffer(buf)
0634         self.__field_data.writetobuffer(buf)
0635         self._bufferendoffset=buf.getcurrentoffset()
0636         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0637 
0638 
0639     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0640         'Reads this packet from the supplied buffer'
0641         self._bufferstartoffset=buf.getcurrentoffset()
0642         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0643         self.__field_header=responseheader()
0644         self.__field_header.readfrombuffer(buf)
0645         self.__field_blockcounter=UINT(**{'sizeinbytes': 1})
0646         self.__field_blockcounter.readfrombuffer(buf)
0647         self.__field_thereismore=BOOL(**{'sizeinbytes': 1})
0648         self.__field_thereismore.readfrombuffer(buf)
0649         self.__field_datasize=UINT(**{'sizeinbytes': 2})
0650         self.__field_datasize.readfrombuffer(buf)
0651         self.__field_data=DATA(**{'sizeinbytes': self.datasize})
0652         self.__field_data.readfrombuffer(buf)
0653         self._bufferendoffset=buf.getcurrentoffset()
0654 
0655 
0656     def __getfield_header(self):
0657         return self.__field_header.getvalue()
0658 
0659     def __setfield_header(self, value):
0660         if isinstance(value,responseheader):
0661             self.__field_header=value
0662         else:
0663             self.__field_header=responseheader(value,)
0664 
0665     def __delfield_header(self): del self.__field_header
0666 
0667     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0668 
0669     def __getfield_blockcounter(self):
0670         return self.__field_blockcounter.getvalue()
0671 
0672     def __setfield_blockcounter(self, value):
0673         if isinstance(value,UINT):
0674             self.__field_blockcounter=value
0675         else:
0676             self.__field_blockcounter=UINT(value,**{'sizeinbytes': 1})
0677 
0678     def __delfield_blockcounter(self): del self.__field_blockcounter
0679 
0680     blockcounter=property(__getfield_blockcounter, __setfield_blockcounter, __delfield_blockcounter, None)
0681 
0682     def __getfield_thereismore(self):
0683         return self.__field_thereismore.getvalue()
0684 
0685     def __setfield_thereismore(self, value):
0686         if isinstance(value,BOOL):
0687             self.__field_thereismore=value
0688         else:
0689             self.__field_thereismore=BOOL(value,**{'sizeinbytes': 1})
0690 
0691     def __delfield_thereismore(self): del self.__field_thereismore
0692 
0693     thereismore=property(__getfield_thereismore, __setfield_thereismore, __delfield_thereismore, "true if there is more data available after this block")
0694 
0695     def __getfield_datasize(self):
0696         return self.__field_datasize.getvalue()
0697 
0698     def __setfield_datasize(self, value):
0699         if isinstance(value,UINT):
0700             self.__field_datasize=value
0701         else:
0702             self.__field_datasize=UINT(value,**{'sizeinbytes': 2})
0703 
0704     def __delfield_datasize(self): del self.__field_datasize
0705 
0706     datasize=property(__getfield_datasize, __setfield_datasize, __delfield_datasize, None)
0707 
0708     def __getfield_data(self):
0709         return self.__field_data.getvalue()
0710 
0711     def __setfield_data(self, value):
0712         if isinstance(value,DATA):
0713             self.__field_data=value
0714         else:
0715             self.__field_data=DATA(value,**{'sizeinbytes': self.datasize})
0716 
0717     def __delfield_data(self): del self.__field_data
0718 
0719     data=property(__getfield_data, __setfield_data, __delfield_data, None)
0720 
0721     def iscontainer(self):
0722         return True
0723 
0724     def containerelements(self):
0725         yield ('header', self.__field_header, None)
0726         yield ('blockcounter', self.__field_blockcounter, None)
0727         yield ('thereismore', self.__field_thereismore, "true if there is more data available after this block")
0728         yield ('datasize', self.__field_datasize, None)
0729         yield ('data', self.__field_data, None)
0730 
0731 
0732 
0733 
0734 class writefilerequest(BaseProtogenClass):
0735     __fields=['header', 'blockcounter', 'thereismore', 'unknown1', 'filesize', 'unknown2', 'filename', 'datalen', 'data']
0736 
0737     def __init__(self, *args, **kwargs):
0738         dict={}
0739         # What was supplied to this function
0740         dict.update(kwargs)
0741         # Parent constructor
0742         super(writefilerequest,self).__init__(**dict)
0743         if self.__class__ is writefilerequest:
0744             self._update(args,dict)
0745 
0746 
0747     def getfields(self):
0748         return self.__fields
0749 
0750 
0751     def _update(self, args, kwargs):
0752         super(writefilerequest,self)._update(args,kwargs)
0753         keys=kwargs.keys()
0754         for key in keys:
0755             if key in self.__fields:
0756                 setattr(self, key, kwargs[key])
0757                 del kwargs[key]
0758         # Were any unrecognized kwargs passed in?
0759         if __debug__:
0760             self._complainaboutunusedargs(writefilerequest,kwargs)
0761         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0762         # Make all P fields that haven't already been constructed
0763 
0764 
0765     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0766         'Writes this packet to the supplied buffer'
0767         self._bufferstartoffset=buf.getcurrentoffset()
0768         try: self.__field_header
0769         except:
0770             self.__field_header=requestheader(**{'command': 0x05})
0771         self.__field_header.writetobuffer(buf)
0772         try: self.__field_blockcounter
0773         except:
0774             self.__field_blockcounter=UINT(**{'sizeinbytes': 1, 'value': 0})
0775         self.__field_blockcounter.writetobuffer(buf)
0776         try: self.__field_thereismore
0777         except:
0778             self.__field_thereismore=BOOL(**{'sizeinbytes': 1, 'value': self.filesize>0x100})
0779         self.__field_thereismore.writetobuffer(buf)
0780         try: self.__field_unknown1
0781         except:
0782             self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'constant': 1})
0783         self.__field_unknown1.writetobuffer(buf)
0784         self.__field_filesize.writetobuffer(buf)
0785         try: self.__field_unknown2
0786         except:
0787             self.__field_unknown2=UINT(**{'sizeinbytes': 4, 'constant': 0x000100ff})
0788         self.__field_unknown2.writetobuffer(buf)
0789         self.__field_filename.writetobuffer(buf)
0790         try: self.__field_datalen
0791         except:
0792             self.__field_datalen=UINT(**{'sizeinbytes': 2, 'value': len(self.data)})
0793         self.__field_datalen.writetobuffer(buf)
0794         self.__field_data.writetobuffer(buf)
0795         self._bufferendoffset=buf.getcurrentoffset()
0796         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0797 
0798 
0799     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0800         'Reads this packet from the supplied buffer'
0801         self._bufferstartoffset=buf.getcurrentoffset()
0802         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0803         self.__field_header=requestheader(**{'command': 0x05})
0804         self.__field_header.readfrombuffer(buf)
0805         self.__field_blockcounter=UINT(**{'sizeinbytes': 1, 'value': 0})
0806         self.__field_blockcounter.readfrombuffer(buf)
0807         self.__field_thereismore=BOOL(**{'sizeinbytes': 1})
0808         self.__field_thereismore.readfrombuffer(buf)
0809         self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'constant': 1})
0810         self.__field_unknown1.readfrombuffer(buf)
0811         self.__field_filesize=UINT(**{'sizeinbytes': 4})
0812         self.__field_filesize.readfrombuffer(buf)
0813         self.__field_unknown2=UINT(**{'sizeinbytes': 4, 'constant': 0x000100ff})
0814         self.__field_unknown2.readfrombuffer(buf)
0815         self.__field_filename=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
0816         self.__field_filename.readfrombuffer(buf)
0817         self.__field_datalen=UINT(**{'sizeinbytes': 2})
0818         self.__field_datalen.readfrombuffer(buf)
0819         self.__field_data=DATA()
0820         self.__field_data.readfrombuffer(buf)
0821         self._bufferendoffset=buf.getcurrentoffset()
0822 
0823 
0824     def __getfield_header(self):
0825         try: self.__field_header
0826         except:
0827             self.__field_header=requestheader(**{'command': 0x05})
0828         return self.__field_header.getvalue()
0829 
0830     def __setfield_header(self, value):
0831         if isinstance(value,requestheader):
0832             self.__field_header=value
0833         else:
0834             self.__field_header=requestheader(value,**{'command': 0x05})
0835 
0836     def __delfield_header(self): del self.__field_header
0837 
0838     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0839 
0840     def __getfield_blockcounter(self):
0841         try: self.__field_blockcounter
0842         except:
0843             self.__field_blockcounter=UINT(**{'sizeinbytes': 1, 'value': 0})
0844         return self.__field_blockcounter.getvalue()
0845 
0846     def __setfield_blockcounter(self, value):
0847         if isinstance(value,UINT):
0848             self.__field_blockcounter=value
0849         else:
0850             self.__field_blockcounter=UINT(value,**{'sizeinbytes': 1, 'value': 0})
0851 
0852     def __delfield_blockcounter(self): del self.__field_blockcounter
0853 
0854     blockcounter=property(__getfield_blockcounter, __setfield_blockcounter, __delfield_blockcounter, None)
0855 
0856     def __getfield_thereismore(self):
0857         try: self.__field_thereismore
0858         except:
0859             self.__field_thereismore=BOOL(**{'sizeinbytes': 1})
0860         return self.__field_thereismore.getvalue()
0861 
0862     def __setfield_thereismore(self, value):
0863         if isinstance(value,BOOL):
0864             self.__field_thereismore=value
0865         else:
0866             self.__field_thereismore=BOOL(value,**{'sizeinbytes': 1, 'value': self.filesize>0x100})
0867 
0868     def __delfield_thereismore(self): del self.__field_thereismore
0869 
0870     thereismore=property(__getfield_thereismore, __setfield_thereismore, __delfield_thereismore, None)
0871 
0872     def __getfield_unknown1(self):
0873         try: self.__field_unknown1
0874         except:
0875             self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'constant': 1})
0876         return self.__field_unknown1.getvalue()
0877 
0878     def __setfield_unknown1(self, value):
0879         if isinstance(value,UINT):
0880             self.__field_unknown1=value
0881         else:
0882             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1, 'constant': 1})
0883 
0884     def __delfield_unknown1(self): del self.__field_unknown1
0885 
0886     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
0887 
0888     def __getfield_filesize(self):
0889         return self.__field_filesize.getvalue()
0890 
0891     def __setfield_filesize(self, value):
0892         if isinstance(value,UINT):
0893             self.__field_filesize=value
0894         else:
0895             self.__field_filesize=UINT(value,**{'sizeinbytes': 4})
0896 
0897     def __delfield_filesize(self): del self.__field_filesize
0898 
0899     filesize=property(__getfield_filesize, __setfield_filesize, __delfield_filesize, None)
0900 
0901     def __getfield_unknown2(self):
0902         try: self.__field_unknown2
0903         except:
0904             self.__field_unknown2=UINT(**{'sizeinbytes': 4, 'constant': 0x000100ff})
0905         return self.__field_unknown2.getvalue()
0906 
0907     def __setfield_unknown2(self, value):
0908         if isinstance(value,UINT):
0909             self.__field_unknown2=value
0910         else:
0911             self.__field_unknown2=UINT(value,**{'sizeinbytes': 4, 'constant': 0x000100ff})
0912 
0913     def __delfield_unknown2(self): del self.__field_unknown2
0914 
0915     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, "probably file attributes")
0916 
0917     def __getfield_filename(self):
0918         return self.__field_filename.getvalue()
0919 
0920     def __setfield_filename(self, value):
0921         if isinstance(value,USTRING):
0922             self.__field_filename=value
0923         else:
0924             self.__field_filename=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
0925 
0926     def __delfield_filename(self): del self.__field_filename
0927 
0928     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
0929 
0930     def __getfield_datalen(self):
0931         try: self.__field_datalen
0932         except:
0933             self.__field_datalen=UINT(**{'sizeinbytes': 2})
0934         return self.__field_datalen.getvalue()
0935 
0936     def __setfield_datalen(self, value):
0937         if isinstance(value,UINT):
0938             self.__field_datalen=value
0939         else:
0940             self.__field_datalen=UINT(value,**{'sizeinbytes': 2, 'value': len(self.data)})
0941 
0942     def __delfield_datalen(self): del self.__field_datalen
0943 
0944     datalen=property(__getfield_datalen, __setfield_datalen, __delfield_datalen, None)
0945 
0946     def __getfield_data(self):
0947         return self.__field_data.getvalue()
0948 
0949     def __setfield_data(self, value):
0950         if isinstance(value,DATA):
0951             self.__field_data=value
0952         else:
0953             self.__field_data=DATA(value,)
0954 
0955     def __delfield_data(self): del self.__field_data
0956 
0957     data=property(__getfield_data, __setfield_data, __delfield_data, None)
0958 
0959     def iscontainer(self):
0960         return True
0961 
0962     def containerelements(self):
0963         yield ('header', self.__field_header, None)
0964         yield ('blockcounter', self.__field_blockcounter, None)
0965         yield ('thereismore', self.__field_thereismore, None)
0966         yield ('unknown1', self.__field_unknown1, None)
0967         yield ('filesize', self.__field_filesize, None)
0968         yield ('unknown2', self.__field_unknown2, "probably file attributes")
0969         yield ('filename', self.__field_filename, None)
0970         yield ('datalen', self.__field_datalen, None)
0971         yield ('data', self.__field_data, None)
0972 
0973 
0974 
0975 
0976 class writefileblockrequest(BaseProtogenClass):
0977     __fields=['header', 'blockcounter', 'thereismore', 'datalen', 'data']
0978 
0979     def __init__(self, *args, **kwargs):
0980         dict={}
0981         # What was supplied to this function
0982         dict.update(kwargs)
0983         # Parent constructor
0984         super(writefileblockrequest,self).__init__(**dict)
0985         if self.__class__ is writefileblockrequest:
0986             self._update(args,dict)
0987 
0988 
0989     def getfields(self):
0990         return self.__fields
0991 
0992 
0993     def _update(self, args, kwargs):
0994         super(writefileblockrequest,self)._update(args,kwargs)
0995         keys=kwargs.keys()
0996         for key in keys:
0997             if key in self.__fields:
0998                 setattr(self, key, kwargs[key])
0999                 del kwargs[key]
1000         # Were any unrecognized kwargs passed in?
1001         if __debug__:
1002             self._complainaboutunusedargs(writefileblockrequest,kwargs)
1003         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1004         # Make all P fields that haven't already been constructed
1005 
1006 
1007     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1008         'Writes this packet to the supplied buffer'
1009         self._bufferstartoffset=buf.getcurrentoffset()
1010         try: self.__field_header
1011         except:
1012             self.__field_header=requestheader(**{'command': 0x05})
1013         self.__field_header.writetobuffer(buf)
1014         self.__field_blockcounter.writetobuffer(buf)
1015         self.__field_thereismore.writetobuffer(buf)
1016         try: self.__field_datalen
1017         except:
1018             self.__field_datalen=UINT(**{'sizeinbytes': 2, 'value': len(self.data)})
1019         self.__field_datalen.writetobuffer(buf)
1020         self.__field_data.writetobuffer(buf)
1021         self._bufferendoffset=buf.getcurrentoffset()
1022         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1023 
1024 
1025     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1026         'Reads this packet from the supplied buffer'
1027         self._bufferstartoffset=buf.getcurrentoffset()
1028         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1029         self.__field_header=requestheader(**{'command': 0x05})
1030         self.__field_header.readfrombuffer(buf)
1031         self.__field_blockcounter=UINT(**{'sizeinbytes': 1})
1032         self.__field_blockcounter.readfrombuffer(buf)
1033         self.__field_thereismore=BOOL(**{'sizeinbytes': 1})
1034         self.__field_thereismore.readfrombuffer(buf)
1035         self.__field_datalen=UINT(**{'sizeinbytes': 2})
1036         self.__field_datalen.readfrombuffer(buf)
1037         self.__field_data=DATA()
1038         self.__field_data.readfrombuffer(buf)
1039         self._bufferendoffset=buf.getcurrentoffset()
1040 
1041 
1042     def __getfield_header(self):
1043         try: self.__field_header
1044         except:
1045             self.__field_header=requestheader(**{'command': 0x05})
1046         return self.__field_header.getvalue()
1047 
1048     def __setfield_header(self, value):
1049         if isinstance(value,requestheader):
1050             self.__field_header=value
1051         else:
1052             self.__field_header=requestheader(value,**{'command': 0x05})
1053 
1054     def __delfield_header(self): del self.__field_header
1055 
1056     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1057 
1058     def __getfield_blockcounter(self):
1059         return self.__field_blockcounter.getvalue()
1060 
1061     def __setfield_blockcounter(self, value):
1062         if isinstance(value,UINT):
1063             self.__field_blockcounter=value
1064         else:
1065             self.__field_blockcounter=UINT(value,**{'sizeinbytes': 1})
1066 
1067     def __delfield_blockcounter(self): del self.__field_blockcounter
1068 
1069     blockcounter=property(__getfield_blockcounter, __setfield_blockcounter, __delfield_blockcounter, None)
1070 
1071     def __getfield_thereismore(self):
1072         return self.__field_thereismore.getvalue()
1073 
1074     def __setfield_thereismore(self, value):
1075         if isinstance(value,BOOL):
1076             self.__field_thereismore=value
1077         else:
1078             self.__field_thereismore=BOOL(value,**{'sizeinbytes': 1})
1079 
1080     def __delfield_thereismore(self): del self.__field_thereismore
1081 
1082     thereismore=property(__getfield_thereismore, __setfield_thereismore, __delfield_thereismore, None)
1083 
1084     def __getfield_datalen(self):
1085         try: self.__field_datalen
1086         except:
1087             self.__field_datalen=UINT(**{'sizeinbytes': 2})
1088         return self.__field_datalen.getvalue()
1089 
1090     def __setfield_datalen(self, value):
1091         if isinstance(value,UINT):
1092             self.__field_datalen=value
1093         else:
1094             self.__field_datalen=UINT(value,**{'sizeinbytes': 2, 'value': len(self.data)})
1095 
1096     def __delfield_datalen(self): del self.__field_datalen
1097 
1098     datalen=property(__getfield_datalen, __setfield_datalen, __delfield_datalen, None)
1099 
1100     def __getfield_data(self):
1101         return self.__field_data.getvalue()
1102 
1103     def __setfield_data(self, value):
1104         if isinstance(value,DATA):
1105             self.__field_data=value
1106         else:
1107             self.__field_data=DATA(value,)
1108 
1109     def __delfield_data(self): del self.__field_data
1110 
1111     data=property(__getfield_data, __setfield_data, __delfield_data, None)
1112 
1113     def iscontainer(self):
1114         return True
1115 
1116     def containerelements(self):
1117         yield ('header', self.__field_header, None)
1118         yield ('blockcounter', self.__field_blockcounter, None)
1119         yield ('thereismore', self.__field_thereismore, None)
1120         yield ('datalen', self.__field_datalen, None)
1121         yield ('data', self.__field_data, None)
1122 
1123 
1124 
1125 
1126 class listdirectoriesrequest(BaseProtogenClass):
1127     "Lists the subdirectories of dirname"
1128     __fields=['header', 'dirname']
1129 
1130     def __init__(self, *args, **kwargs):
1131         dict={}
1132         # What was supplied to this function
1133         dict.update(kwargs)
1134         # Parent constructor
1135         super(listdirectoriesrequest,self).__init__(**dict)
1136         if self.__class__ is listdirectoriesrequest:
1137             self._update(args,dict)
1138 
1139 
1140     def getfields(self):
1141         return self.__fields
1142 
1143 
1144     def _update(self, args, kwargs):
1145         super(listdirectoriesrequest,self)._update(args,kwargs)
1146         keys=kwargs.keys()
1147         for key in keys:
1148             if key in self.__fields:
1149                 setattr(self, key, kwargs[key])
1150                 del kwargs[key]
1151         # Were any unrecognized kwargs passed in?
1152         if __debug__:
1153             self._complainaboutunusedargs(listdirectoriesrequest,kwargs)
1154         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1155         # Make all P fields that haven't already been constructed
1156 
1157 
1158     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1159         'Writes this packet to the supplied buffer'
1160         self._bufferstartoffset=buf.getcurrentoffset()
1161         try: self.__field_header
1162         except:
1163             self.__field_header=requestheader(**{'command': 0x02})
1164         self.__field_header.writetobuffer(buf)
1165         self.__field_dirname.writetobuffer(buf)
1166         self._bufferendoffset=buf.getcurrentoffset()
1167         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1168 
1169 
1170     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1171         'Reads this packet from the supplied buffer'
1172         self._bufferstartoffset=buf.getcurrentoffset()
1173         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1174         self.__field_header=requestheader(**{'command': 0x02})
1175         self.__field_header.readfrombuffer(buf)
1176         self.__field_dirname=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
1177         self.__field_dirname.readfrombuffer(buf)
1178         self._bufferendoffset=buf.getcurrentoffset()
1179 
1180 
1181     def __getfield_header(self):
1182         try: self.__field_header
1183         except:
1184             self.__field_header=requestheader(**{'command': 0x02})
1185         return self.__field_header.getvalue()
1186 
1187     def __setfield_header(self, value):
1188         if isinstance(value,requestheader):
1189             self.__field_header=value
1190         else:
1191             self.__field_header=requestheader(value,**{'command': 0x02})
1192 
1193     def __delfield_header(self): del self.__field_header
1194 
1195     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1196 
1197     def __getfield_dirname(self):
1198         return self.__field_dirname.getvalue()
1199 
1200     def __setfield_dirname(self, value):
1201         if isinstance(value,USTRING):
1202             self.__field_dirname=value
1203         else:
1204             self.__field_dirname=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
1205 
1206     def __delfield_dirname(self): del self.__field_dirname
1207 
1208     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
1209 
1210     def iscontainer(self):
1211         return True
1212 
1213     def containerelements(self):
1214         yield ('header', self.__field_header, None)
1215         yield ('dirname', self.__field_dirname, None)
1216 
1217 
1218 
1219 
1220 class listdirectoriesresponse(BaseProtogenClass):
1221     __fields=['header', 'numentries', 'datalen', 'items']
1222 
1223     def __init__(self, *args, **kwargs):
1224         dict={}
1225         # What was supplied to this function
1226         dict.update(kwargs)
1227         # Parent constructor
1228         super(listdirectoriesresponse,self).__init__(**dict)
1229         if self.__class__ is listdirectoriesresponse:
1230             self._update(args,dict)
1231 
1232 
1233     def getfields(self):
1234         return self.__fields
1235 
1236 
1237     def _update(self, args, kwargs):
1238         super(listdirectoriesresponse,self)._update(args,kwargs)
1239         keys=kwargs.keys()
1240         for key in keys:
1241             if key in self.__fields:
1242                 setattr(self, key, kwargs[key])
1243                 del kwargs[key]
1244         # Were any unrecognized kwargs passed in?
1245         if __debug__:
1246             self._complainaboutunusedargs(listdirectoriesresponse,kwargs)
1247         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1248         # Make all P fields that haven't already been constructed
1249 
1250 
1251     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1252         'Writes this packet to the supplied buffer'
1253         self._bufferstartoffset=buf.getcurrentoffset()
1254         self.__field_header.writetobuffer(buf)
1255         self.__field_numentries.writetobuffer(buf)
1256         if self.numentries>0:
1257             self.__field_datalen.writetobuffer(buf)
1258             self.__field_items.writetobuffer(buf)
1259         self._bufferendoffset=buf.getcurrentoffset()
1260         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1261 
1262 
1263     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1264         'Reads this packet from the supplied buffer'
1265         self._bufferstartoffset=buf.getcurrentoffset()
1266         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1267         self.__field_header=responseheader()
1268         self.__field_header.readfrombuffer(buf)
1269         self.__field_numentries=UINT(**{'sizeinbytes': 2})
1270         self.__field_numentries.readfrombuffer(buf)
1271         if self.numentries>0:
1272             self.__field_datalen=UINT(**{'sizeinbytes': 2})
1273             self.__field_datalen.readfrombuffer(buf)
1274             self.__field_items=LIST(**{'elementclass': _gen_p_brew_114, 'length': self.numentries})
1275             self.__field_items.readfrombuffer(buf)
1276         self._bufferendoffset=buf.getcurrentoffset()
1277 
1278 
1279     def __getfield_header(self):
1280         return self.__field_header.getvalue()
1281 
1282     def __setfield_header(self, value):
1283         if isinstance(value,responseheader):
1284             self.__field_header=value
1285         else:
1286             self.__field_header=responseheader(value,)
1287 
1288     def __delfield_header(self): del self.__field_header
1289 
1290     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1291 
1292     def __getfield_numentries(self):
1293         return self.__field_numentries.getvalue()
1294 
1295     def __setfield_numentries(self, value):
1296         if isinstance(value,UINT):
1297             self.__field_numentries=value
1298         else:
1299             self.__field_numentries=UINT(value,**{'sizeinbytes': 2})
1300 
1301     def __delfield_numentries(self): del self.__field_numentries
1302 
1303     numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, None)
1304 
1305     def __getfield_datalen(self):
1306         return self.__field_datalen.getvalue()
1307 
1308     def __setfield_datalen(self, value):
1309         if isinstance(value,UINT):
1310             self.__field_datalen=value
1311         else:
1312             self.__field_datalen=UINT(value,**{'sizeinbytes': 2})
1313 
1314     def __delfield_datalen(self): del self.__field_datalen
1315 
1316     datalen=property(__getfield_datalen, __setfield_datalen, __delfield_datalen, None)
1317 
1318     def __getfield_items(self):
1319         return self.__field_items.getvalue()
1320 
1321     def __setfield_items(self, value):
1322         if isinstance(value,LIST):
1323             self.__field_items=value
1324         else:
1325             self.__field_items=LIST(value,**{'elementclass': _gen_p_brew_114, 'length': self.numentries})
1326 
1327     def __delfield_items(self): del self.__field_items
1328 
1329     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1330 
1331     def iscontainer(self):
1332         return True
1333 
1334     def containerelements(self):
1335         yield ('header', self.__field_header, None)
1336         yield ('numentries', self.__field_numentries, None)
1337         if self.numentries>0:
1338             yield ('datalen', self.__field_datalen, None)
1339             yield ('items', self.__field_items, None)
1340 
1341 
1342 
1343 
1344 class _gen_p_brew_114(BaseProtogenClass):
1345     'Anonymous inner class'
1346     __fields=['subdir']
1347 
1348     def __init__(self, *args, **kwargs):
1349         dict={}
1350         # What was supplied to this function
1351         dict.update(kwargs)
1352         # Parent constructor
1353         super(_gen_p_brew_114,self).__init__(**dict)
1354         if self.__class__ is _gen_p_brew_114:
1355             self._update(args,dict)
1356 
1357 
1358     def getfields(self):
1359         return self.__fields
1360 
1361 
1362     def _update(self, args, kwargs):
1363         super(_gen_p_brew_114,self)._update(args,kwargs)
1364         keys=kwargs.keys()
1365         for key in keys:
1366             if key in self.__fields:
1367                 setattr(self, key, kwargs[key])
1368                 del kwargs[key]
1369         # Were any unrecognized kwargs passed in?
1370         if __debug__:
1371             self._complainaboutunusedargs(_gen_p_brew_114,kwargs)
1372         if len(args):
1373             dict2={ 'encoding': PHONE_ENCODING }
1374             dict2.update(kwargs)
1375             kwargs=dict2
1376             self.__field_subdir=USTRING(*args,**dict2)
1377         # Make all P fields that haven't already been constructed
1378 
1379 
1380     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1381         'Writes this packet to the supplied buffer'
1382         self._bufferstartoffset=buf.getcurrentoffset()
1383         self.__field_subdir.writetobuffer(buf)
1384         self._bufferendoffset=buf.getcurrentoffset()
1385         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1386 
1387 
1388     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1389         'Reads this packet from the supplied buffer'
1390         self._bufferstartoffset=buf.getcurrentoffset()
1391         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1392         self.__field_subdir=USTRING(**{ 'encoding': PHONE_ENCODING })
1393         self.__field_subdir.readfrombuffer(buf)
1394         self._bufferendoffset=buf.getcurrentoffset()
1395 
1396 
1397     def __getfield_subdir(self):
1398         return self.__field_subdir.getvalue()
1399 
1400     def __setfield_subdir(self, value):
1401         if isinstance(value,USTRING):
1402             self.__field_subdir=value
1403         else:
1404             self.__field_subdir=USTRING(value,**{ 'encoding': PHONE_ENCODING })
1405 
1406     def __delfield_subdir(self): del self.__field_subdir
1407 
1408     subdir=property(__getfield_subdir, __setfield_subdir, __delfield_subdir, None)
1409 
1410     def iscontainer(self):
1411         return True
1412 
1413     def containerelements(self):
1414         yield ('subdir', self.__field_subdir, None)
1415 
1416 
1417 
1418 
1419 class listfilerequest(BaseProtogenClass):
1420     "This gets one directory entry (files only) at a time"
1421     __fields=['header', 'entrynumber', 'dirname']
1422 
1423     def __init__(self, *args, **kwargs):
1424         dict={}
1425         # What was supplied to this function
1426         dict.update(kwargs)
1427         # Parent constructor
1428         super(listfilerequest,self).__init__(**dict)
1429         if self.__class__ is listfilerequest:
1430             self._update(args,dict)
1431 
1432 
1433     def getfields(self):
1434         return self.__fields
1435 
1436 
1437     def _update(self, args, kwargs):
1438         super(listfilerequest,self)._update(args,kwargs)
1439         keys=kwargs.keys()
1440         for key in keys:
1441             if key in self.__fields:
1442                 setattr(self, key, kwargs[key])
1443                 del kwargs[key]
1444         # Were any unrecognized kwargs passed in?
1445         if __debug__:
1446             self._complainaboutunusedargs(listfilerequest,kwargs)
1447         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1448         # Make all P fields that haven't already been constructed
1449 
1450 
1451     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1452         'Writes this packet to the supplied buffer'
1453         self._bufferstartoffset=buf.getcurrentoffset()
1454         try: self.__field_header
1455         except:
1456             self.__field_header=requestheader(**{'command': 0x0b})
1457         self.__field_header.writetobuffer(buf)
1458         self.__field_entrynumber.writetobuffer(buf)
1459         self.__field_dirname.writetobuffer(buf)
1460         self._bufferendoffset=buf.getcurrentoffset()
1461         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1462 
1463 
1464     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1465         'Reads this packet from the supplied buffer'
1466         self._bufferstartoffset=buf.getcurrentoffset()
1467         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1468         self.__field_header=requestheader(**{'command': 0x0b})
1469         self.__field_header.readfrombuffer(buf)
1470         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
1471         self.__field_entrynumber.readfrombuffer(buf)
1472         self.__field_dirname=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
1473         self.__field_dirname.readfrombuffer(buf)
1474         self._bufferendoffset=buf.getcurrentoffset()
1475 
1476 
1477     def __getfield_header(self):
1478         try: self.__field_header
1479         except:
1480             self.__field_header=requestheader(**{'command': 0x0b})
1481         return self.__field_header.getvalue()
1482 
1483     def __setfield_header(self, value):
1484         if isinstance(value,requestheader):
1485             self.__field_header=value
1486         else:
1487             self.__field_header=requestheader(value,**{'command': 0x0b})
1488 
1489     def __delfield_header(self): del self.__field_header
1490 
1491     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1492 
1493     def __getfield_entrynumber(self):
1494         return self.__field_entrynumber.getvalue()
1495 
1496     def __setfield_entrynumber(self, value):
1497         if isinstance(value,UINT):
1498             self.__field_entrynumber=value
1499         else:
1500             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
1501 
1502     def __delfield_entrynumber(self): del self.__field_entrynumber
1503 
1504     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
1505 
1506     def __getfield_dirname(self):
1507         return self.__field_dirname.getvalue()
1508 
1509     def __setfield_dirname(self, value):
1510         if isinstance(value,USTRING):
1511             self.__field_dirname=value
1512         else:
1513             self.__field_dirname=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
1514 
1515     def __delfield_dirname(self): del self.__field_dirname
1516 
1517     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
1518 
1519     def iscontainer(self):
1520         return True
1521 
1522     def containerelements(self):
1523         yield ('header', self.__field_header, None)
1524         yield ('entrynumber', self.__field_entrynumber, None)
1525         yield ('dirname', self.__field_dirname, None)
1526 
1527 
1528 
1529 
1530 class listfileresponse(BaseProtogenClass):
1531     __fields=['header', 'entrynumber', 'unknown1', 'date', 'size', 'unknown2', 'spuriouszero', 'dirnamelen', 'extrazero', 'filename']
1532 
1533     def __init__(self, *args, **kwargs):
1534         dict={}
1535         # What was supplied to this function
1536         dict.update(kwargs)
1537         # Parent constructor
1538         super(listfileresponse,self).__init__(**dict)
1539         if self.__class__ is listfileresponse:
1540             self._update(args,dict)
1541 
1542 
1543     def getfields(self):
1544         return self.__fields
1545 
1546 
1547     def _update(self, args, kwargs):
1548         super(listfileresponse,self)._update(args,kwargs)
1549         keys=kwargs.keys()
1550         for key in keys:
1551             if key in self.__fields:
1552                 setattr(self, key, kwargs[key])
1553                 del kwargs[key]
1554         # Were any unrecognized kwargs passed in?
1555         if __debug__:
1556             self._complainaboutunusedargs(listfileresponse,kwargs)
1557         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1558         # Make all P fields that haven't already been constructed
1559 
1560 
1561     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1562         'Writes this packet to the supplied buffer'
1563         self._bufferstartoffset=buf.getcurrentoffset()
1564         self.__field_header.writetobuffer(buf)
1565         self.__field_entrynumber.writetobuffer(buf)
1566         self.__field_unknown1.writetobuffer(buf)
1567         self.__field_date.writetobuffer(buf)
1568         self.__field_size.writetobuffer(buf)
1569         self.__field_unknown2.writetobuffer(buf)
1570         self.__field_spuriouszero.writetobuffer(buf)
1571         self.__field_dirnamelen.writetobuffer(buf)
1572         self.__field_extrazero.writetobuffer(buf)
1573         self.__field_filename.writetobuffer(buf)
1574         self._bufferendoffset=buf.getcurrentoffset()
1575         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1576 
1577 
1578     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1579         'Reads this packet from the supplied buffer'
1580         self._bufferstartoffset=buf.getcurrentoffset()
1581         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1582         self.__field_header=responseheader()
1583         self.__field_header.readfrombuffer(buf)
1584         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
1585         self.__field_entrynumber.readfrombuffer(buf)
1586         self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 4})
1587         self.__field_unknown1.readfrombuffer(buf)
1588         self.__field_date=UINT(**{'sizeinbytes': 4})
1589         self.__field_date.readfrombuffer(buf)
1590         self.__field_size=UINT(**{'sizeinbytes': 4})
1591         self.__field_size.readfrombuffer(buf)
1592         self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 4})
1593         self.__field_unknown2.readfrombuffer(buf)
1594         self.__field_spuriouszero=com_brew.SPURIOUSZERO()
1595         self.__field_spuriouszero.readfrombuffer(buf)
1596         self.__field_dirnamelen=UINT(**{'sizeinbytes': 1})
1597         self.__field_dirnamelen.readfrombuffer(buf)
1598         self.__field_extrazero=com_brew.EXTRAZERO()
1599         self.__field_extrazero.readfrombuffer(buf)
1600         self.__field_filename=USTRING(**{'terminator': None, 'pascal': True,               'encoding': PHONE_ENCODING })
1601         self.__field_filename.readfrombuffer(buf)
1602         self._bufferendoffset=buf.getcurrentoffset()
1603 
1604 
1605     def __getfield_header(self):
1606         return self.__field_header.getvalue()
1607 
1608     def __setfield_header(self, value):
1609         if isinstance(value,responseheader):
1610             self.__field_header=value
1611         else:
1612             self.__field_header=responseheader(value,)
1613 
1614     def __delfield_header(self): del self.__field_header
1615 
1616     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1617 
1618     def __getfield_entrynumber(self):
1619         return self.__field_entrynumber.getvalue()
1620 
1621     def __setfield_entrynumber(self, value):
1622         if isinstance(value,UINT):
1623             self.__field_entrynumber=value
1624         else:
1625             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
1626 
1627     def __delfield_entrynumber(self): del self.__field_entrynumber
1628 
1629     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
1630 
1631     def __getfield_unknown1(self):
1632         return self.__field_unknown1.getvalue()
1633 
1634     def __setfield_unknown1(self, value):
1635         if isinstance(value,UNKNOWN):
1636             self.__field_unknown1=value
1637         else:
1638             self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 4})
1639 
1640     def __delfield_unknown1(self): del self.__field_unknown1
1641 
1642     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, "probably the file attributes")
1643 
1644     def __getfield_date(self):
1645         return self.__field_date.getvalue()
1646 
1647     def __setfield_date(self, value):
1648         if isinstance(value,UINT):
1649             self.__field_date=value
1650         else:
1651             self.__field_date=UINT(value,**{'sizeinbytes': 4})
1652 
1653     def __delfield_date(self): del self.__field_date
1654 
1655     date=property(__getfield_date, __setfield_date, __delfield_date, None)
1656 
1657     def __getfield_size(self):
1658         return self.__field_size.getvalue()
1659 
1660     def __setfield_size(self, value):
1661         if isinstance(value,UINT):
1662             self.__field_size=value
1663         else:
1664             self.__field_size=UINT(value,**{'sizeinbytes': 4})
1665 
1666     def __delfield_size(self): del self.__field_size
1667 
1668     size=property(__getfield_size, __setfield_size, __delfield_size, None)
1669 
1670     def __getfield_unknown2(self):
1671         return self.__field_unknown2.getvalue()
1672 
1673     def __setfield_unknown2(self, value):
1674         if isinstance(value,UNKNOWN):
1675             self.__field_unknown2=value
1676         else:
1677             self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 4})
1678 
1679     def __delfield_unknown2(self): del self.__field_unknown2
1680 
1681     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1682 
1683     def __getfield_spuriouszero(self):
1684         return self.__field_spuriouszero.getvalue()
1685 
1686     def __setfield_spuriouszero(self, value):
1687         if isinstance(value,com_brew.SPURIOUSZERO):
1688             self.__field_spuriouszero=value
1689         else:
1690             self.__field_spuriouszero=com_brew.SPURIOUSZERO(value,)
1691 
1692     def __delfield_spuriouszero(self): del self.__field_spuriouszero
1693 
1694     spuriouszero=property(__getfield_spuriouszero, __setfield_spuriouszero, __delfield_spuriouszero, "on some models there is a zero here")
1695 
1696     def __getfield_dirnamelen(self):
1697         return self.__field_dirnamelen.getvalue()
1698 
1699     def __setfield_dirnamelen(self, value):
1700         if isinstance(value,UINT):
1701             self.__field_dirnamelen=value
1702         else:
1703             self.__field_dirnamelen=UINT(value,**{'sizeinbytes': 1})
1704 
1705     def __delfield_dirnamelen(self): del self.__field_dirnamelen
1706 
1707     dirnamelen=property(__getfield_dirnamelen, __setfield_dirnamelen, __delfield_dirnamelen, "which portion of the filename is the directory, including the last /")
1708 
1709     def __getfield_extrazero(self):
1710         return self.__field_extrazero.getvalue()
1711 
1712     def __setfield_extrazero(self, value):
1713         if isinstance(value,com_brew.EXTRAZERO):
1714             self.__field_extrazero=value
1715         else:
1716             self.__field_extrazero=com_brew.EXTRAZERO(value,)
1717 
1718     def __delfield_extrazero(self): del self.__field_extrazero
1719 
1720     extrazero=property(__getfield_extrazero, __setfield_extrazero, __delfield_extrazero, "on some models there is a zero here")
1721 
1722     def __getfield_filename(self):
1723         return self.__field_filename.getvalue()
1724 
1725     def __setfield_filename(self, value):
1726         if isinstance(value,USTRING):
1727             self.__field_filename=value
1728         else:
1729             self.__field_filename=USTRING(value,**{'terminator': None, 'pascal': True,               'encoding': PHONE_ENCODING })
1730 
1731     def __delfield_filename(self): del self.__field_filename
1732 
1733     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
1734 
1735     def iscontainer(self):
1736         return True
1737 
1738     def containerelements(self):
1739         yield ('header', self.__field_header, None)
1740         yield ('entrynumber', self.__field_entrynumber, None)
1741         yield ('unknown1', self.__field_unknown1, "probably the file attributes")
1742         yield ('date', self.__field_date, None)
1743         yield ('size', self.__field_size, None)
1744         yield ('unknown2', self.__field_unknown2, None)
1745         yield ('spuriouszero', self.__field_spuriouszero, "on some models there is a zero here")
1746         yield ('dirnamelen', self.__field_dirnamelen, "which portion of the filename is the directory, including the last /")
1747         yield ('extrazero', self.__field_extrazero, "on some models there is a zero here")
1748         yield ('filename', self.__field_filename, None)
1749 
1750 
1751 
1752 
1753 class listdirectoryrequest(BaseProtogenClass):
1754     "This gets one directory entry (directory only) at a time"
1755     __fields=['header', 'entrynumber', 'dirname']
1756 
1757     def __init__(self, *args, **kwargs):
1758         dict={}
1759         # What was supplied to this function
1760         dict.update(kwargs)
1761         # Parent constructor
1762         super(listdirectoryrequest,self).__init__(**dict)
1763         if self.__class__ is listdirectoryrequest:
1764             self._update(args,dict)
1765 
1766 
1767     def getfields(self):
1768         return self.__fields
1769 
1770 
1771     def _update(self, args, kwargs):
1772         super(listdirectoryrequest,self)._update(args,kwargs)
1773         keys=kwargs.keys()
1774         for key in keys:
1775             if key in self.__fields:
1776                 setattr(self, key, kwargs[key])
1777                 del kwargs[key]
1778         # Were any unrecognized kwargs passed in?
1779         if __debug__:
1780             self._complainaboutunusedargs(listdirectoryrequest,kwargs)
1781         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1782         # Make all P fields that haven't already been constructed
1783 
1784 
1785     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1786         'Writes this packet to the supplied buffer'
1787         self._bufferstartoffset=buf.getcurrentoffset()
1788         try: self.__field_header
1789         except:
1790             self.__field_header=requestheader(**{'command': 0x0a})
1791         self.__field_header.writetobuffer(buf)
1792         self.__field_entrynumber.writetobuffer(buf)
1793         self.__field_dirname.writetobuffer(buf)
1794         self._bufferendoffset=buf.getcurrentoffset()
1795         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1796 
1797 
1798     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1799         'Reads this packet from the supplied buffer'
1800         self._bufferstartoffset=buf.getcurrentoffset()
1801         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1802         self.__field_header=requestheader(**{'command': 0x0a})
1803         self.__field_header.readfrombuffer(buf)
1804         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
1805         self.__field_entrynumber.readfrombuffer(buf)
1806         self.__field_dirname=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
1807         self.__field_dirname.readfrombuffer(buf)
1808         self._bufferendoffset=buf.getcurrentoffset()
1809 
1810 
1811     def __getfield_header(self):
1812         try: self.__field_header
1813         except:
1814             self.__field_header=requestheader(**{'command': 0x0a})
1815         return self.__field_header.getvalue()
1816 
1817     def __setfield_header(self, value):
1818         if isinstance(value,requestheader):
1819             self.__field_header=value
1820         else:
1821             self.__field_header=requestheader(value,**{'command': 0x0a})
1822 
1823     def __delfield_header(self): del self.__field_header
1824 
1825     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1826 
1827     def __getfield_entrynumber(self):
1828         return self.__field_entrynumber.getvalue()
1829 
1830     def __setfield_entrynumber(self, value):
1831         if isinstance(value,UINT):
1832             self.__field_entrynumber=value
1833         else:
1834             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
1835 
1836     def __delfield_entrynumber(self): del self.__field_entrynumber
1837 
1838     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
1839 
1840     def __getfield_dirname(self):
1841         return self.__field_dirname.getvalue()
1842 
1843     def __setfield_dirname(self, value):
1844         if isinstance(value,USTRING):
1845             self.__field_dirname=value
1846         else:
1847             self.__field_dirname=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
1848 
1849     def __delfield_dirname(self): del self.__field_dirname
1850 
1851     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
1852 
1853     def iscontainer(self):
1854         return True
1855 
1856     def containerelements(self):
1857         yield ('header', self.__field_header, None)
1858         yield ('entrynumber', self.__field_entrynumber, None)
1859         yield ('dirname', self.__field_dirname, None)
1860 
1861 
1862 
1863 
1864 class listdirectoryresponse(BaseProtogenClass):
1865     __fields=['header', 'entrynumber', 'unknown1', 'extrazero', 'subdir']
1866 
1867     def __init__(self, *args, **kwargs):
1868         dict={}
1869         # What was supplied to this function
1870         dict.update(kwargs)
1871         # Parent constructor
1872         super(listdirectoryresponse,self).__init__(**dict)
1873         if self.__class__ is listdirectoryresponse:
1874             self._update(args,dict)
1875 
1876 
1877     def getfields(self):
1878         return self.__fields
1879 
1880 
1881     def _update(self, args, kwargs):
1882         super(listdirectoryresponse,self)._update(args,kwargs)
1883         keys=kwargs.keys()
1884         for key in keys:
1885             if key in self.__fields:
1886                 setattr(self, key, kwargs[key])
1887                 del kwargs[key]
1888         # Were any unrecognized kwargs passed in?
1889         if __debug__:
1890             self._complainaboutunusedargs(listdirectoryresponse,kwargs)
1891         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1892         # Make all P fields that haven't already been constructed
1893 
1894 
1895     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1896         'Writes this packet to the supplied buffer'
1897         self._bufferstartoffset=buf.getcurrentoffset()
1898         self.__field_header.writetobuffer(buf)
1899         self.__field_entrynumber.writetobuffer(buf)
1900         self.__field_unknown1.writetobuffer(buf)
1901         self.__field_extrazero.writetobuffer(buf)
1902         self.__field_subdir.writetobuffer(buf)
1903         self._bufferendoffset=buf.getcurrentoffset()
1904         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1905 
1906 
1907     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1908         'Reads this packet from the supplied buffer'
1909         self._bufferstartoffset=buf.getcurrentoffset()
1910         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1911         self.__field_header=responseheader()
1912         self.__field_header.readfrombuffer(buf)
1913         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
1914         self.__field_entrynumber.readfrombuffer(buf)
1915         self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 17})
1916         self.__field_unknown1.readfrombuffer(buf)
1917         self.__field_extrazero=com_brew.EXTRAZERO()
1918         self.__field_extrazero.readfrombuffer(buf)
1919         self.__field_subdir=USTRING(**{'terminator': None, 'pascal': True,               'encoding': PHONE_ENCODING })
1920         self.__field_subdir.readfrombuffer(buf)
1921         self._bufferendoffset=buf.getcurrentoffset()
1922 
1923 
1924     def __getfield_header(self):
1925         return self.__field_header.getvalue()
1926 
1927     def __setfield_header(self, value):
1928         if isinstance(value,responseheader):
1929             self.__field_header=value
1930         else:
1931             self.__field_header=responseheader(value,)
1932 
1933     def __delfield_header(self): del self.__field_header
1934 
1935     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1936 
1937     def __getfield_entrynumber(self):
1938         return self.__field_entrynumber.getvalue()
1939 
1940     def __setfield_entrynumber(self, value):
1941         if isinstance(value,UINT):
1942             self.__field_entrynumber=value
1943         else:
1944             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
1945 
1946     def __delfield_entrynumber(self): del self.__field_entrynumber
1947 
1948     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
1949 
1950     def __getfield_unknown1(self):
1951         return self.__field_unknown1.getvalue()
1952 
1953     def __setfield_unknown1(self, value):
1954         if isinstance(value,UNKNOWN):
1955             self.__field_unknown1=value
1956         else:
1957             self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 17})
1958 
1959     def __delfield_unknown1(self): del self.__field_unknown1
1960 
1961     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, "probably the directory attributes")
1962 
1963     def __getfield_extrazero(self):
1964         return self.__field_extrazero.getvalue()
1965 
1966     def __setfield_extrazero(self, value):
1967         if isinstance(value,com_brew.EXTRAZERO):
1968             self.__field_extrazero=value
1969         else:
1970             self.__field_extrazero=com_brew.EXTRAZERO(value,)
1971 
1972     def __delfield_extrazero(self): del self.__field_extrazero
1973 
1974     extrazero=property(__getfield_extrazero, __setfield_extrazero, __delfield_extrazero, "on some models there is a zero here")
1975 
1976     def __getfield_subdir(self):
1977         return self.__field_subdir.getvalue()
1978 
1979     def __setfield_subdir(self, value):
1980         if isinstance(value,USTRING):
1981             self.__field_subdir=value
1982         else:
1983             self.__field_subdir=USTRING(value,**{'terminator': None, 'pascal': True,               'encoding': PHONE_ENCODING })
1984 
1985     def __delfield_subdir(self): del self.__field_subdir
1986 
1987     subdir=property(__getfield_subdir, __setfield_subdir, __delfield_subdir, None)
1988 
1989     def iscontainer(self):
1990         return True
1991 
1992     def containerelements(self):
1993         yield ('header', self.__field_header, None)
1994         yield ('entrynumber', self.__field_entrynumber, None)
1995         yield ('unknown1', self.__field_unknown1, "probably the directory attributes")
1996         yield ('extrazero', self.__field_extrazero, "on some models there is a zero here")
1997         yield ('subdir', self.__field_subdir, None)
1998 
1999 
2000 
2001 
2002 class statfilerequest(BaseProtogenClass):
2003     "Get the status of the file"
2004     __fields=['header', 'filename']
2005 
2006     def __init__(self, *args, **kwargs):
2007         dict={}
2008         # What was supplied to this function
2009         dict.update(kwargs)
2010         # Parent constructor
2011         super(statfilerequest,self).__init__(**dict)
2012         if self.__class__ is statfilerequest:
2013             self._update(args,dict)
2014 
2015 
2016     def getfields(self):
2017         return self.__fields
2018 
2019 
2020     def _update(self, args, kwargs):
2021         super(statfilerequest,self)._update(args,kwargs)
2022         keys=kwargs.keys()
2023         for key in keys:
2024             if key in self.__fields:
2025                 setattr(self, key, kwargs[key])
2026                 del kwargs[key]
2027         # Were any unrecognized kwargs passed in?
2028         if __debug__:
2029             self._complainaboutunusedargs(statfilerequest,kwargs)
2030         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2031         # Make all P fields that haven't already been constructed
2032 
2033 
2034     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2035         'Writes this packet to the supplied buffer'
2036         self._bufferstartoffset=buf.getcurrentoffset()
2037         try: self.__field_header
2038         except:
2039             self.__field_header=requestheader(**{ 'command': 7 })
2040         self.__field_header.writetobuffer(buf)
2041         self.__field_filename.writetobuffer(buf)
2042         self._bufferendoffset=buf.getcurrentoffset()
2043         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2044 
2045 
2046     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2047         'Reads this packet from the supplied buffer'
2048         self._bufferstartoffset=buf.getcurrentoffset()
2049         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2050         self.__field_header=requestheader(**{ 'command': 7 })
2051         self.__field_header.readfrombuffer(buf)
2052         self.__field_filename=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2053         self.__field_filename.readfrombuffer(buf)
2054         self._bufferendoffset=buf.getcurrentoffset()
2055 
2056 
2057     def __getfield_header(self):
2058         try: self.__field_header
2059         except:
2060             self.__field_header=requestheader(**{ 'command': 7 })
2061         return self.__field_header.getvalue()
2062 
2063     def __setfield_header(self, value):
2064         if isinstance(value,requestheader):
2065             self.__field_header=value
2066         else:
2067             self.__field_header=requestheader(value,**{ 'command': 7 })
2068 
2069     def __delfield_header(self): del self.__field_header
2070 
2071     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2072 
2073     def __getfield_filename(self):
2074         return self.__field_filename.getvalue()
2075 
2076     def __setfield_filename(self, value):
2077         if isinstance(value,USTRING):
2078             self.__field_filename=value
2079         else:
2080             self.__field_filename=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2081 
2082     def __delfield_filename(self): del self.__field_filename
2083 
2084     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
2085 
2086     def iscontainer(self):
2087         return True
2088 
2089     def containerelements(self):
2090         yield ('header', self.__field_header, None)
2091         yield ('filename', self.__field_filename, None)
2092 
2093 
2094 
2095 
2096 class statfileresponse(BaseProtogenClass):
2097     __fields=['header', 'unknown1', 'date', 'size']
2098 
2099     def __init__(self, *args, **kwargs):
2100         dict={}
2101         # What was supplied to this function
2102         dict.update(kwargs)
2103         # Parent constructor
2104         super(statfileresponse,self).__init__(**dict)
2105         if self.__class__ is statfileresponse:
2106             self._update(args,dict)
2107 
2108 
2109     def getfields(self):
2110         return self.__fields
2111 
2112 
2113     def _update(self, args, kwargs):
2114         super(statfileresponse,self)._update(args,kwargs)
2115         keys=kwargs.keys()
2116         for key in keys:
2117             if key in self.__fields:
2118                 setattr(self, key, kwargs[key])
2119                 del kwargs[key]
2120         # Were any unrecognized kwargs passed in?
2121         if __debug__:
2122             self._complainaboutunusedargs(statfileresponse,kwargs)
2123         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2124         # Make all P fields that haven't already been constructed
2125 
2126 
2127     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2128         'Writes this packet to the supplied buffer'
2129         self._bufferstartoffset=buf.getcurrentoffset()
2130         self.__field_header.writetobuffer(buf)
2131         self.__field_unknown1.writetobuffer(buf)
2132         self.__field_date.writetobuffer(buf)
2133         self.__field_size.writetobuffer(buf)
2134         self._bufferendoffset=buf.getcurrentoffset()
2135         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2136 
2137 
2138     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2139         'Reads this packet from the supplied buffer'
2140         self._bufferstartoffset=buf.getcurrentoffset()
2141         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2142         self.__field_header=responseheader()
2143         self.__field_header.readfrombuffer(buf)
2144         self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 4})
2145         self.__field_unknown1.readfrombuffer(buf)
2146         self.__field_date=UINT(**{'sizeinbytes': 4})
2147         self.__field_date.readfrombuffer(buf)
2148         self.__field_size=UINT(**{'sizeinbytes': 4})
2149         self.__field_size.readfrombuffer(buf)
2150         self._bufferendoffset=buf.getcurrentoffset()
2151 
2152 
2153     def __getfield_header(self):
2154         return self.__field_header.getvalue()
2155 
2156     def __setfield_header(self, value):
2157         if isinstance(value,responseheader):
2158             self.__field_header=value
2159         else:
2160             self.__field_header=responseheader(value,)
2161 
2162     def __delfield_header(self): del self.__field_header
2163 
2164     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2165 
2166     def __getfield_unknown1(self):
2167         return self.__field_unknown1.getvalue()
2168 
2169     def __setfield_unknown1(self, value):
2170         if isinstance(value,UNKNOWN):
2171             self.__field_unknown1=value
2172         else:
2173             self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 4})
2174 
2175     def __delfield_unknown1(self): del self.__field_unknown1
2176 
2177     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, "probably the file attributes")
2178 
2179     def __getfield_date(self):
2180         return self.__field_date.getvalue()
2181 
2182     def __setfield_date(self, value):
2183         if isinstance(value,UINT):
2184             self.__field_date=value
2185         else:
2186             self.__field_date=UINT(value,**{'sizeinbytes': 4})
2187 
2188     def __delfield_date(self): del self.__field_date
2189 
2190     date=property(__getfield_date, __setfield_date, __delfield_date, None)
2191 
2192     def __getfield_size(self):
2193         return self.__field_size.getvalue()
2194 
2195     def __setfield_size(self, value):
2196         if isinstance(value,UINT):
2197             self.__field_size=value
2198         else:
2199             self.__field_size=UINT(value,**{'sizeinbytes': 4})
2200 
2201     def __delfield_size(self): del self.__field_size
2202 
2203     size=property(__getfield_size, __setfield_size, __delfield_size, None)
2204 
2205     def iscontainer(self):
2206         return True
2207 
2208     def containerelements(self):
2209         yield ('header', self.__field_header, None)
2210         yield ('unknown1', self.__field_unknown1, "probably the file attributes")
2211         yield ('date', self.__field_date, None)
2212         yield ('size', self.__field_size, None)
2213 
2214 
2215 
2216 
2217 class mkdirrequest(BaseProtogenClass):
2218     __fields=['header', 'dirname']
2219 
2220     def __init__(self, *args, **kwargs):
2221         dict={}
2222         # What was supplied to this function
2223         dict.update(kwargs)
2224         # Parent constructor
2225         super(mkdirrequest,self).__init__(**dict)
2226         if self.__class__ is mkdirrequest:
2227             self._update(args,dict)
2228 
2229 
2230     def getfields(self):
2231         return self.__fields
2232 
2233 
2234     def _update(self, args, kwargs):
2235         super(mkdirrequest,self)._update(args,kwargs)
2236         keys=kwargs.keys()
2237         for key in keys:
2238             if key in self.__fields:
2239                 setattr(self, key, kwargs[key])
2240                 del kwargs[key]
2241         # Were any unrecognized kwargs passed in?
2242         if __debug__:
2243             self._complainaboutunusedargs(mkdirrequest,kwargs)
2244         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2245         # Make all P fields that haven't already been constructed
2246 
2247 
2248     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2249         'Writes this packet to the supplied buffer'
2250         self._bufferstartoffset=buf.getcurrentoffset()
2251         try: self.__field_header
2252         except:
2253             self.__field_header=requestheader(**{'command': 0x00})
2254         self.__field_header.writetobuffer(buf)
2255         self.__field_dirname.writetobuffer(buf)
2256         self._bufferendoffset=buf.getcurrentoffset()
2257         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2258 
2259 
2260     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2261         'Reads this packet from the supplied buffer'
2262         self._bufferstartoffset=buf.getcurrentoffset()
2263         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2264         self.__field_header=requestheader(**{'command': 0x00})
2265         self.__field_header.readfrombuffer(buf)
2266         self.__field_dirname=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2267         self.__field_dirname.readfrombuffer(buf)
2268         self._bufferendoffset=buf.getcurrentoffset()
2269 
2270 
2271     def __getfield_header(self):
2272         try: self.__field_header
2273         except:
2274             self.__field_header=requestheader(**{'command': 0x00})
2275         return self.__field_header.getvalue()
2276 
2277     def __setfield_header(self, value):
2278         if isinstance(value,requestheader):
2279             self.__field_header=value
2280         else:
2281             self.__field_header=requestheader(value,**{'command': 0x00})
2282 
2283     def __delfield_header(self): del self.__field_header
2284 
2285     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2286 
2287     def __getfield_dirname(self):
2288         return self.__field_dirname.getvalue()
2289 
2290     def __setfield_dirname(self, value):
2291         if isinstance(value,USTRING):
2292             self.__field_dirname=value
2293         else:
2294             self.__field_dirname=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2295 
2296     def __delfield_dirname(self): del self.__field_dirname
2297 
2298     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
2299 
2300     def iscontainer(self):
2301         return True
2302 
2303     def containerelements(self):
2304         yield ('header', self.__field_header, None)
2305         yield ('dirname', self.__field_dirname, None)
2306 
2307 
2308 
2309 
2310 class rmdirrequest(BaseProtogenClass):
2311     __fields=['header', 'dirname']
2312 
2313     def __init__(self, *args, **kwargs):
2314         dict={}
2315         # What was supplied to this function
2316         dict.update(kwargs)
2317         # Parent constructor
2318         super(rmdirrequest,self).__init__(**dict)
2319         if self.__class__ is rmdirrequest:
2320             self._update(args,dict)
2321 
2322 
2323     def getfields(self):
2324         return self.__fields
2325 
2326 
2327     def _update(self, args, kwargs):
2328         super(rmdirrequest,self)._update(args,kwargs)
2329         keys=kwargs.keys()
2330         for key in keys:
2331             if key in self.__fields:
2332                 setattr(self, key, kwargs[key])
2333                 del kwargs[key]
2334         # Were any unrecognized kwargs passed in?
2335         if __debug__:
2336             self._complainaboutunusedargs(rmdirrequest,kwargs)
2337         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2338         # Make all P fields that haven't already been constructed
2339 
2340 
2341     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2342         'Writes this packet to the supplied buffer'
2343         self._bufferstartoffset=buf.getcurrentoffset()
2344         try: self.__field_header
2345         except:
2346             self.__field_header=requestheader(**{'command': 0x01})
2347         self.__field_header.writetobuffer(buf)
2348         self.__field_dirname.writetobuffer(buf)
2349         self._bufferendoffset=buf.getcurrentoffset()
2350         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2351 
2352 
2353     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2354         'Reads this packet from the supplied buffer'
2355         self._bufferstartoffset=buf.getcurrentoffset()
2356         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2357         self.__field_header=requestheader(**{'command': 0x01})
2358         self.__field_header.readfrombuffer(buf)
2359         self.__field_dirname=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2360         self.__field_dirname.readfrombuffer(buf)
2361         self._bufferendoffset=buf.getcurrentoffset()
2362 
2363 
2364     def __getfield_header(self):
2365         try: self.__field_header
2366         except:
2367             self.__field_header=requestheader(**{'command': 0x01})
2368         return self.__field_header.getvalue()
2369 
2370     def __setfield_header(self, value):
2371         if isinstance(value,requestheader):
2372             self.__field_header=value
2373         else:
2374             self.__field_header=requestheader(value,**{'command': 0x01})
2375 
2376     def __delfield_header(self): del self.__field_header
2377 
2378     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2379 
2380     def __getfield_dirname(self):
2381         return self.__field_dirname.getvalue()
2382 
2383     def __setfield_dirname(self, value):
2384         if isinstance(value,USTRING):
2385             self.__field_dirname=value
2386         else:
2387             self.__field_dirname=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2388 
2389     def __delfield_dirname(self): del self.__field_dirname
2390 
2391     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
2392 
2393     def iscontainer(self):
2394         return True
2395 
2396     def containerelements(self):
2397         yield ('header', self.__field_header, None)
2398         yield ('dirname', self.__field_dirname, None)
2399 
2400 
2401 
2402 
2403 class rmfilerequest(BaseProtogenClass):
2404     __fields=['header', 'filename']
2405 
2406     def __init__(self, *args, **kwargs):
2407         dict={}
2408         # What was supplied to this function
2409         dict.update(kwargs)
2410         # Parent constructor
2411         super(rmfilerequest,self).__init__(**dict)
2412         if self.__class__ is rmfilerequest:
2413             self._update(args,dict)
2414 
2415 
2416     def getfields(self):
2417         return self.__fields
2418 
2419 
2420     def _update(self, args, kwargs):
2421         super(rmfilerequest,self)._update(args,kwargs)
2422         keys=kwargs.keys()
2423         for key in keys:
2424             if key in self.__fields:
2425                 setattr(self, key, kwargs[key])
2426                 del kwargs[key]
2427         # Were any unrecognized kwargs passed in?
2428         if __debug__:
2429             self._complainaboutunusedargs(rmfilerequest,kwargs)
2430         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2431         # Make all P fields that haven't already been constructed
2432 
2433 
2434     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2435         'Writes this packet to the supplied buffer'
2436         self._bufferstartoffset=buf.getcurrentoffset()
2437         try: self.__field_header
2438         except:
2439             self.__field_header=requestheader(**{'command': 0x06})
2440         self.__field_header.writetobuffer(buf)
2441         self.__field_filename.writetobuffer(buf)
2442         self._bufferendoffset=buf.getcurrentoffset()
2443         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2444 
2445 
2446     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2447         'Reads this packet from the supplied buffer'
2448         self._bufferstartoffset=buf.getcurrentoffset()
2449         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2450         self.__field_header=requestheader(**{'command': 0x06})
2451         self.__field_header.readfrombuffer(buf)
2452         self.__field_filename=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2453         self.__field_filename.readfrombuffer(buf)
2454         self._bufferendoffset=buf.getcurrentoffset()
2455 
2456 
2457     def __getfield_header(self):
2458         try: self.__field_header
2459         except:
2460             self.__field_header=requestheader(**{'command': 0x06})
2461         return self.__field_header.getvalue()
2462 
2463     def __setfield_header(self, value):
2464         if isinstance(value,requestheader):
2465             self.__field_header=value
2466         else:
2467             self.__field_header=requestheader(value,**{'command': 0x06})
2468 
2469     def __delfield_header(self): del self.__field_header
2470 
2471     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2472 
2473     def __getfield_filename(self):
2474         return self.__field_filename.getvalue()
2475 
2476     def __setfield_filename(self, value):
2477         if isinstance(value,USTRING):
2478             self.__field_filename=value
2479         else:
2480             self.__field_filename=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
2481 
2482     def __delfield_filename(self): del self.__field_filename
2483 
2484     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
2485 
2486     def iscontainer(self):
2487         return True
2488 
2489     def containerelements(self):
2490         yield ('header', self.__field_header, None)
2491         yield ('filename', self.__field_filename, None)
2492 
2493 
2494 
2495 
2496 class memoryconfigrequest(BaseProtogenClass):
2497     __fields=['header']
2498 
2499     def __init__(self, *args, **kwargs):
2500         dict={}
2501         # What was supplied to this function
2502         dict.update(kwargs)
2503         # Parent constructor
2504         super(memoryconfigrequest,self).__init__(**dict)
2505         if self.__class__ is memoryconfigrequest:
2506             self._update(args,dict)
2507 
2508 
2509     def getfields(self):
2510         return self.__fields
2511 
2512 
2513     def _update(self, args, kwargs):
2514         super(memoryconfigrequest,self)._update(args,kwargs)
2515         keys=kwargs.keys()
2516         for key in keys:
2517             if key in self.__fields:
2518                 setattr(self, key, kwargs[key])
2519                 del kwargs[key]
2520         # Were any unrecognized kwargs passed in?
2521         if __debug__:
2522             self._complainaboutunusedargs(memoryconfigrequest,kwargs)
2523         if len(args):
2524             dict2={'command': 0x0c}
2525             dict2.update(kwargs)
2526             kwargs=dict2
2527             self.__field_header=requestheader(*args,**dict2)
2528         # Make all P fields that haven't already been constructed
2529 
2530 
2531     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2532         'Writes this packet to the supplied buffer'
2533         self._bufferstartoffset=buf.getcurrentoffset()
2534         try: self.__field_header
2535         except:
2536             self.__field_header=requestheader(**{'command': 0x0c})
2537         self.__field_header.writetobuffer(buf)
2538         self._bufferendoffset=buf.getcurrentoffset()
2539         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2540 
2541 
2542     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2543         'Reads this packet from the supplied buffer'
2544         self._bufferstartoffset=buf.getcurrentoffset()
2545         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2546         self.__field_header=requestheader(**{'command': 0x0c})
2547         self.__field_header.readfrombuffer(buf)
2548         self._bufferendoffset=buf.getcurrentoffset()
2549 
2550 
2551     def __getfield_header(self):
2552         try: self.__field_header
2553         except:
2554             self.__field_header=requestheader(**{'command': 0x0c})
2555         return self.__field_header.getvalue()
2556 
2557     def __setfield_header(self, value):
2558         if isinstance(value,requestheader):
2559             self.__field_header=value
2560         else:
2561             self.__field_header=requestheader(value,**{'command': 0x0c})
2562 
2563     def __delfield_header(self): del self.__field_header
2564 
2565     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2566 
2567     def iscontainer(self):
2568         return True
2569 
2570     def containerelements(self):
2571         yield ('header', self.__field_header, None)
2572 
2573 
2574 
2575 
2576 class memoryconfigresponse(BaseProtogenClass):
2577     __fields=['header', 'amountofmemory']
2578 
2579     def __init__(self, *args, **kwargs):
2580         dict={}
2581         # What was supplied to this function
2582         dict.update(kwargs)
2583         # Parent constructor
2584         super(memoryconfigresponse,self).__init__(**dict)
2585         if self.__class__ is memoryconfigresponse:
2586             self._update(args,dict)
2587 
2588 
2589     def getfields(self):
2590         return self.__fields
2591 
2592 
2593     def _update(self, args, kwargs):
2594         super(memoryconfigresponse,self)._update(args,kwargs)
2595         keys=kwargs.keys()
2596         for key in keys:
2597             if key in self.__fields:
2598                 setattr(self, key, kwargs[key])
2599                 del kwargs[key]
2600         # Were any unrecognized kwargs passed in?
2601         if __debug__:
2602             self._complainaboutunusedargs(memoryconfigresponse,kwargs)
2603         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2604         # Make all P fields that haven't already been constructed
2605 
2606 
2607     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2608         'Writes this packet to the supplied buffer'
2609         self._bufferstartoffset=buf.getcurrentoffset()
2610         self.__field_header.writetobuffer(buf)
2611         self.__field_amountofmemory.writetobuffer(buf)
2612         self._bufferendoffset=buf.getcurrentoffset()
2613         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2614 
2615 
2616     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2617         'Reads this packet from the supplied buffer'
2618         self._bufferstartoffset=buf.getcurrentoffset()
2619         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2620         self.__field_header=responseheader()
2621         self.__field_header.readfrombuffer(buf)
2622         self.__field_amountofmemory=UINT(**{'sizeinbytes': 4})
2623         self.__field_amountofmemory.readfrombuffer(buf)
2624         self._bufferendoffset=buf.getcurrentoffset()
2625 
2626 
2627     def __getfield_header(self):
2628         return self.__field_header.getvalue()
2629 
2630     def __setfield_header(self, value):
2631         if isinstance(value,responseheader):
2632             self.__field_header=value
2633         else:
2634             self.__field_header=responseheader(value,)
2635 
2636     def __delfield_header(self): del self.__field_header
2637 
2638     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2639 
2640     def __getfield_amountofmemory(self):
2641         return self.__field_amountofmemory.getvalue()
2642 
2643     def __setfield_amountofmemory(self, value):
2644         if isinstance(value,UINT):
2645             self.__field_amountofmemory=value
2646         else:
2647             self.__field_amountofmemory=UINT(value,**{'sizeinbytes': 4})
2648 
2649     def __delfield_amountofmemory(self): del self.__field_amountofmemory
2650 
2651     amountofmemory=property(__getfield_amountofmemory, __setfield_amountofmemory, __delfield_amountofmemory, "how much memory the EFS has in bytes")
2652 
2653     def iscontainer(self):
2654         return True
2655 
2656     def containerelements(self):
2657         yield ('header', self.__field_header, None)
2658         yield ('amountofmemory', self.__field_amountofmemory, "how much memory the EFS has in bytes")
2659 
2660 
2661 
2662 
2663 class firmwarerequest(BaseProtogenClass):
2664     __fields=['command']
2665 
2666     def __init__(self, *args, **kwargs):
2667         dict={}
2668         # What was supplied to this function
2669         dict.update(kwargs)
2670         # Parent constructor
2671         super(firmwarerequest,self).__init__(**dict)
2672         if self.__class__ is firmwarerequest:
2673             self._update(args,dict)
2674 
2675 
2676     def getfields(self):
2677         return self.__fields
2678 
2679 
2680     def _update(self, args, kwargs):
2681         super(firmwarerequest,self)._update(args,kwargs)
2682         keys=kwargs.keys()
2683         for key in keys:
2684             if key in self.__fields:
2685                 setattr(self, key, kwargs[key])
2686                 del kwargs[key]
2687         # Were any unrecognized kwargs passed in?
2688         if __debug__:
2689             self._complainaboutunusedargs(firmwarerequest,kwargs)
2690         if len(args):
2691             dict2={'sizeinbytes': 1, 'constant': 0x00}
2692             dict2.update(kwargs)
2693             kwargs=dict2
2694             self.__field_command=UINT(*args,**dict2)
2695         # Make all P fields that haven't already been constructed
2696 
2697 
2698     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2699         'Writes this packet to the supplied buffer'
2700         self._bufferstartoffset=buf.getcurrentoffset()
2701         try: self.__field_command
2702         except:
2703             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
2704         self.__field_command.writetobuffer(buf)
2705         self._bufferendoffset=buf.getcurrentoffset()
2706         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2707 
2708 
2709     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2710         'Reads this packet from the supplied buffer'
2711         self._bufferstartoffset=buf.getcurrentoffset()
2712         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2713         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
2714         self.__field_command.readfrombuffer(buf)
2715         self._bufferendoffset=buf.getcurrentoffset()
2716 
2717 
2718     def __getfield_command(self):
2719         try: self.__field_command
2720         except:
2721             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
2722         return self.__field_command.getvalue()
2723 
2724     def __setfield_command(self, value):
2725         if isinstance(value,UINT):
2726             self.__field_command=value
2727         else:
2728             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
2729 
2730     def __delfield_command(self): del self.__field_command
2731 
2732     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2733 
2734     def iscontainer(self):
2735         return True
2736 
2737     def containerelements(self):
2738         yield ('command', self.__field_command, None)
2739 
2740 
2741 
2742 
2743 class firmwareresponse(BaseProtogenClass):
2744     __fields=['command', 'date1', 'time1', 'date2', 'time2', 'string1', 'dunno1', 'date3', 'dunno2', 'time3', 'dunno3', 'firmware']
2745 
2746     def __init__(self, *args, **kwargs):
2747         dict={}
2748         # What was supplied to this function
2749         dict.update(kwargs)
2750         # Parent constructor
2751         super(firmwareresponse,self).__init__(**dict)
2752         if self.__class__ is firmwareresponse:
2753             self._update(args,dict)
2754 
2755 
2756     def getfields(self):
2757         return self.__fields
2758 
2759 
2760     def _update(self, args, kwargs):
2761         super(firmwareresponse,self)._update(args,kwargs)
2762         keys=kwargs.keys()
2763         for key in keys:
2764             if key in self.__fields:
2765                 setattr(self, key, kwargs[key])
2766                 del kwargs[key]
2767         # Were any unrecognized kwargs passed in?
2768         if __debug__:
2769             self._complainaboutunusedargs(firmwareresponse,kwargs)
2770         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2771         # Make all P fields that haven't already been constructed
2772 
2773 
2774     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2775         'Writes this packet to the supplied buffer'
2776         self._bufferstartoffset=buf.getcurrentoffset()
2777         self.__field_command.writetobuffer(buf)
2778         self.__field_date1.writetobuffer(buf)
2779         self.__field_time1.writetobuffer(buf)
2780         self.__field_date2.writetobuffer(buf)
2781         self.__field_time2.writetobuffer(buf)
2782         self.__field_string1.writetobuffer(buf)
2783         self.__field_dunno1.writetobuffer(buf)
2784         self.__field_date3.writetobuffer(buf)
2785         self.__field_dunno2.writetobuffer(buf)
2786         self.__field_time3.writetobuffer(buf)
2787         self.__field_dunno3.writetobuffer(buf)
2788         self.__field_firmware.writetobuffer(buf)
2789         self._bufferendoffset=buf.getcurrentoffset()
2790         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2791 
2792 
2793     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2794         'Reads this packet from the supplied buffer'
2795         self._bufferstartoffset=buf.getcurrentoffset()
2796         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2797         self.__field_command=UINT(**{'sizeinbytes': 1})
2798         self.__field_command.readfrombuffer(buf)
2799         self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
2800         self.__field_date1.readfrombuffer(buf)
2801         self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2802         self.__field_time1.readfrombuffer(buf)
2803         self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
2804         self.__field_date2.readfrombuffer(buf)
2805         self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2806         self.__field_time2.readfrombuffer(buf)
2807         self.__field_string1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2808         self.__field_string1.readfrombuffer(buf)
2809         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1})
2810         self.__field_dunno1.readfrombuffer(buf)
2811         self.__field_date3=USTRING(**{'sizeinbytes': 11, 'terminator': None})
2812         self.__field_date3.readfrombuffer(buf)
2813         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1})
2814         self.__field_dunno2.readfrombuffer(buf)
2815         self.__field_time3=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2816         self.__field_time3.readfrombuffer(buf)
2817         self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 11})
2818         self.__field_dunno3.readfrombuffer(buf)
2819         self.__field_firmware=USTRING(**{'sizeinbytes': 10, 'terminator': None})
2820         self.__field_firmware.readfrombuffer(buf)
2821         self._bufferendoffset=buf.getcurrentoffset()
2822 
2823 
2824     def __getfield_command(self):
2825         return self.__field_command.getvalue()
2826 
2827     def __setfield_command(self, value):
2828         if isinstance(value,UINT):
2829             self.__field_command=value
2830         else:
2831             self.__field_command=UINT(value,**{'sizeinbytes': 1})
2832 
2833     def __delfield_command(self): del self.__field_command
2834 
2835     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2836 
2837     def __getfield_date1(self):
2838         return self.__field_date1.getvalue()
2839 
2840     def __setfield_date1(self, value):
2841         if isinstance(value,USTRING):
2842             self.__field_date1=value
2843         else:
2844             self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
2845 
2846     def __delfield_date1(self): del self.__field_date1
2847 
2848     date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
2849 
2850     def __getfield_time1(self):
2851         return self.__field_time1.getvalue()
2852 
2853     def __setfield_time1(self, value):
2854         if isinstance(value,USTRING):
2855             self.__field_time1=value
2856         else:
2857             self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2858 
2859     def __delfield_time1(self): del self.__field_time1
2860 
2861     time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
2862 
2863     def __getfield_date2(self):
2864         return self.__field_date2.getvalue()
2865 
2866     def __setfield_date2(self, value):
2867         if isinstance(value,USTRING):
2868             self.__field_date2=value
2869         else:
2870             self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
2871 
2872     def __delfield_date2(self): del self.__field_date2
2873 
2874     date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
2875 
2876     def __getfield_time2(self):
2877         return self.__field_time2.getvalue()
2878 
2879     def __setfield_time2(self, value):
2880         if isinstance(value,USTRING):
2881             self.__field_time2=value
2882         else:
2883             self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2884 
2885     def __delfield_time2(self): del self.__field_time2
2886 
2887     time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
2888 
2889     def __getfield_string1(self):
2890         return self.__field_string1.getvalue()
2891 
2892     def __setfield_string1(self, value):
2893         if isinstance(value,USTRING):
2894             self.__field_string1=value
2895         else:
2896             self.__field_string1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2897 
2898     def __delfield_string1(self): del self.__field_string1
2899 
2900     string1=property(__getfield_string1, __setfield_string1, __delfield_string1, None)
2901 
2902     def __getfield_dunno1(self):
2903         return self.__field_dunno1.getvalue()
2904 
2905     def __setfield_dunno1(self, value):
2906         if isinstance(value,UNKNOWN):
2907             self.__field_dunno1=value
2908         else:
2909             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1})
2910 
2911     def __delfield_dunno1(self): del self.__field_dunno1
2912 
2913     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2914 
2915     def __getfield_date3(self):
2916         return self.__field_date3.getvalue()
2917 
2918     def __setfield_date3(self, value):
2919         if isinstance(value,USTRING):
2920             self.__field_date3=value
2921         else:
2922             self.__field_date3=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
2923 
2924     def __delfield_date3(self): del self.__field_date3
2925 
2926     date3=property(__getfield_date3, __setfield_date3, __delfield_date3, None)
2927 
2928     def __getfield_dunno2(self):
2929         return self.__field_dunno2.getvalue()
2930 
2931     def __setfield_dunno2(self, value):
2932         if isinstance(value,UNKNOWN):
2933             self.__field_dunno2=value
2934         else:
2935             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1})
2936 
2937     def __delfield_dunno2(self): del self.__field_dunno2
2938 
2939     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
2940 
2941     def __getfield_time3(self):
2942         return self.__field_time3.getvalue()
2943 
2944     def __setfield_time3(self, value):
2945         if isinstance(value,USTRING):
2946             self.__field_time3=value
2947         else:
2948             self.__field_time3=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2949 
2950     def __delfield_time3(self): del self.__field_time3
2951 
2952     time3=property(__getfield_time3, __setfield_time3, __delfield_time3, None)
2953 
2954     def __getfield_dunno3(self):
2955         return self.__field_dunno3.getvalue()
2956 
2957     def __setfield_dunno3(self, value):
2958         if isinstance(value,UNKNOWN):
2959             self.__field_dunno3=value
2960         else:
2961             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 11})
2962 
2963     def __delfield_dunno3(self): del self.__field_dunno3
2964 
2965     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
2966 
2967     def __getfield_firmware(self):
2968         return self.__field_firmware.getvalue()
2969 
2970     def __setfield_firmware(self, value):
2971         if isinstance(value,USTRING):
2972             self.__field_firmware=value
2973         else:
2974             self.__field_firmware=USTRING(value,**{'sizeinbytes': 10, 'terminator': None})
2975 
2976     def __delfield_firmware(self): del self.__field_firmware
2977 
2978     firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
2979 
2980     def iscontainer(self):
2981         return True
2982 
2983     def containerelements(self):
2984         yield ('command', self.__field_command, None)
2985         yield ('date1', self.__field_date1, None)
2986         yield ('time1', self.__field_time1, None)
2987         yield ('date2', self.__field_date2, None)
2988         yield ('time2', self.__field_time2, None)
2989         yield ('string1', self.__field_string1, None)
2990         yield ('dunno1', self.__field_dunno1, None)
2991         yield ('date3', self.__field_date3, None)
2992         yield ('dunno2', self.__field_dunno2, None)
2993         yield ('time3', self.__field_time3, None)
2994         yield ('dunno3', self.__field_dunno3, None)
2995         yield ('firmware', self.__field_firmware, None)
2996 
2997 
2998 
2999 
3000 class ESN_req(BaseProtogenClass):
3001     __fields=['command']
3002 
3003     def __init__(self, *args, **kwargs):
3004         dict={}
3005         # What was supplied to this function
3006         dict.update(kwargs)
3007         # Parent constructor
3008         super(ESN_req,self).__init__(**dict)
3009         if self.__class__ is ESN_req:
3010             self._update(args,dict)
3011 
3012 
3013     def getfields(self):
3014         return self.__fields
3015 
3016 
3017     def _update(self, args, kwargs):
3018         super(ESN_req,self)._update(args,kwargs)
3019         keys=kwargs.keys()
3020         for key in keys:
3021             if key in self.__fields:
3022                 setattr(self, key, kwargs[key])
3023                 del kwargs[key]
3024         # Were any unrecognized kwargs passed in?
3025         if __debug__:
3026             self._complainaboutunusedargs(ESN_req,kwargs)
3027         if len(args):
3028             dict2={'sizeinbytes': 1,  'default': 1, 'constant': 1 }
3029             dict2.update(kwargs)
3030             kwargs=dict2
3031             self.__field_command=UINT(*args,**dict2)
3032         # Make all P fields that haven't already been constructed
3033 
3034 
3035     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3036         'Writes this packet to the supplied buffer'
3037         self._bufferstartoffset=buf.getcurrentoffset()
3038         try: self.__field_command
3039         except:
3040             self.__field_command=UINT(**{'sizeinbytes': 1,  'default': 1, 'constant': 1 })
3041         self.__field_command.writetobuffer(buf)
3042         self._bufferendoffset=buf.getcurrentoffset()
3043         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3044 
3045 
3046     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3047         'Reads this packet from the supplied buffer'
3048         self._bufferstartoffset=buf.getcurrentoffset()
3049         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3050         self.__field_command=UINT(**{'sizeinbytes': 1,  'default': 1, 'constant': 1 })
3051         self.__field_command.readfrombuffer(buf)
3052         self._bufferendoffset=buf.getcurrentoffset()
3053 
3054 
3055     def __getfield_command(self):
3056         try: self.__field_command
3057         except:
3058             self.__field_command=UINT(**{'sizeinbytes': 1,  'default': 1, 'constant': 1 })
3059         return self.__field_command.getvalue()
3060 
3061     def __setfield_command(self, value):
3062         if isinstance(value,UINT):
3063             self.__field_command=value
3064         else:
3065             self.__field_command=UINT(value,**{'sizeinbytes': 1,  'default': 1, 'constant': 1 })
3066 
3067     def __delfield_command(self): del self.__field_command
3068 
3069     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3070 
3071     def iscontainer(self):
3072         return True
3073 
3074     def containerelements(self):
3075         yield ('command', self.__field_command, None)
3076 
3077 
3078 
3079 
3080 class ESN_resp(BaseProtogenClass):
3081     __fields=['command', 'esn']
3082 
3083     def __init__(self, *args, **kwargs):
3084         dict={}
3085         # What was supplied to this function
3086         dict.update(kwargs)
3087         # Parent constructor
3088         super(ESN_resp,self).__init__(**dict)
3089         if self.__class__ is ESN_resp:
3090             self._update(args,dict)
3091 
3092 
3093     def getfields(self):
3094         return self.__fields
3095 
3096 
3097     def _update(self, args, kwargs):
3098         super(ESN_resp,self)._update(args,kwargs)
3099         keys=kwargs.keys()
3100         for key in keys:
3101             if key in self.__fields:
3102                 setattr(self, key, kwargs[key])
3103                 del kwargs[key]
3104         # Were any unrecognized kwargs passed in?
3105         if __debug__:
3106             self._complainaboutunusedargs(ESN_resp,kwargs)
3107         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3108         # Make all P fields that haven't already been constructed
3109 
3110 
3111     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3112         'Writes this packet to the supplied buffer'
3113         self._bufferstartoffset=buf.getcurrentoffset()
3114         self.__field_command.writetobuffer(buf)
3115         self.__field_esn.writetobuffer(buf)
3116         self._bufferendoffset=buf.getcurrentoffset()
3117         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3118 
3119 
3120     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3121         'Reads this packet from the supplied buffer'
3122         self._bufferstartoffset=buf.getcurrentoffset()
3123         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3124         self.__field_command=UINT(**{'sizeinbytes': 1,  'constant': 1 })
3125         self.__field_command.readfrombuffer(buf)
3126         self.__field_esn=UINT(**{'sizeinbytes': 4})
3127         self.__field_esn.readfrombuffer(buf)
3128         self._bufferendoffset=buf.getcurrentoffset()
3129 
3130 
3131     def __getfield_command(self):
3132         return self.__field_command.getvalue()
3133 
3134     def __setfield_command(self, value):
3135         if isinstance(value,UINT):
3136             self.__field_command=value
3137         else:
3138             self.__field_command=UINT(value,**{'sizeinbytes': 1,  'constant': 1 })
3139 
3140     def __delfield_command(self): del self.__field_command
3141 
3142     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3143 
3144     def __getfield_esn(self):
3145         return self.__field_esn.getvalue()
3146 
3147     def __setfield_esn(self, value):
3148         if isinstance(value,UINT):
3149             self.__field_esn=value
3150         else:
3151             self.__field_esn=UINT(value,**{'sizeinbytes': 4})
3152 
3153     def __delfield_esn(self): del self.__field_esn
3154 
3155     esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
3156 
3157     def iscontainer(self):
3158         return True
3159 
3160     def containerelements(self):
3161         yield ('command', self.__field_command, None)
3162         yield ('esn', self.__field_esn, None)
3163 
3164 
3165 
3166 
3167 class testing0crequest(BaseProtogenClass):
3168     __fields=['command']
3169 
3170     def __init__(self, *args, **kwargs):
3171         dict={}
3172         # What was supplied to this function
3173         dict.update(kwargs)
3174         # Parent constructor
3175         super(testing0crequest,self).__init__(**dict)
3176         if self.__class__ is testing0crequest:
3177             self._update(args,dict)
3178 
3179 
3180     def getfields(self):
3181         return self.__fields
3182 
3183 
3184     def _update(self, args, kwargs):
3185         super(testing0crequest,self)._update(args,kwargs)
3186         keys=kwargs.keys()
3187         for key in keys:
3188             if key in self.__fields:
3189                 setattr(self, key, kwargs[key])
3190                 del kwargs[key]
3191         # Were any unrecognized kwargs passed in?
3192         if __debug__:
3193             self._complainaboutunusedargs(testing0crequest,kwargs)
3194         if len(args):
3195             dict2={'sizeinbytes': 1, 'constant': 0x0c}
3196             dict2.update(kwargs)
3197             kwargs=dict2
3198             self.__field_command=UINT(*args,**dict2)
3199         # Make all P fields that haven't already been constructed
3200 
3201 
3202     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3203         'Writes this packet to the supplied buffer'
3204         self._bufferstartoffset=buf.getcurrentoffset()
3205         try: self.__field_command
3206         except:
3207             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
3208         self.__field_command.writetobuffer(buf)
3209         self._bufferendoffset=buf.getcurrentoffset()
3210         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3211 
3212 
3213     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3214         'Reads this packet from the supplied buffer'
3215         self._bufferstartoffset=buf.getcurrentoffset()
3216         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3217         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
3218         self.__field_command.readfrombuffer(buf)
3219         self._bufferendoffset=buf.getcurrentoffset()
3220 
3221 
3222     def __getfield_command(self):
3223         try: self.__field_command
3224         except:
3225             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
3226         return self.__field_command.getvalue()
3227 
3228     def __setfield_command(self, value):
3229         if isinstance(value,UINT):
3230             self.__field_command=value
3231         else:
3232             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0c})
3233 
3234     def __delfield_command(self): del self.__field_command
3235 
3236     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3237 
3238     def iscontainer(self):
3239         return True
3240 
3241     def containerelements(self):
3242         yield ('command', self.__field_command, None)
3243 
3244 
3245 
3246 
3247 class testing0cresponse(BaseProtogenClass):
3248     __fields=['pad']
3249 
3250     def __init__(self, *args, **kwargs):
3251         dict={}
3252         # What was supplied to this function
3253         dict.update(kwargs)
3254         # Parent constructor
3255         super(testing0cresponse,self).__init__(**dict)
3256         if self.__class__ is testing0cresponse:
3257             self._update(args,dict)
3258 
3259 
3260     def getfields(self):
3261         return self.__fields
3262 
3263 
3264     def _update(self, args, kwargs):
3265         super(testing0cresponse,self)._update(args,kwargs)
3266         keys=kwargs.keys()
3267         for key in keys:
3268             if key in self.__fields:
3269                 setattr(self, key, kwargs[key])
3270                 del kwargs[key]
3271         # Were any unrecognized kwargs passed in?
3272         if __debug__:
3273             self._complainaboutunusedargs(testing0cresponse,kwargs)
3274         if len(args):
3275             dict2={}
3276             dict2.update(kwargs)
3277             kwargs=dict2
3278             self.__field_pad=UNKNOWN(*args,**dict2)
3279         # Make all P fields that haven't already been constructed
3280 
3281 
3282     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3283         'Writes this packet to the supplied buffer'
3284         self._bufferstartoffset=buf.getcurrentoffset()
3285         self.__field_pad.writetobuffer(buf)
3286         self._bufferendoffset=buf.getcurrentoffset()
3287         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3288 
3289 
3290     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3291         'Reads this packet from the supplied buffer'
3292         self._bufferstartoffset=buf.getcurrentoffset()
3293         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3294         self.__field_pad=UNKNOWN()
3295         self.__field_pad.readfrombuffer(buf)
3296         self._bufferendoffset=buf.getcurrentoffset()
3297 
3298 
3299     def __getfield_pad(self):
3300         return self.__field_pad.getvalue()
3301 
3302     def __setfield_pad(self, value):
3303         if isinstance(value,UNKNOWN):
3304             self.__field_pad=value
3305         else:
3306             self.__field_pad=UNKNOWN(value,)
3307 
3308     def __delfield_pad(self): del self.__field_pad
3309 
3310     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3311 
3312     def iscontainer(self):
3313         return True
3314 
3315     def containerelements(self):
3316         yield ('pad', self.__field_pad, None)
3317 
3318 
3319 
3320 
3321 class setmoderequest(BaseProtogenClass):
3322     __fields=['command', 'request', 'zero']
3323 
3324     def __init__(self, *args, **kwargs):
3325         dict={}
3326         # What was supplied to this function
3327         dict.update(kwargs)
3328         # Parent constructor
3329         super(setmoderequest,self).__init__(**dict)
3330         if self.__class__ is setmoderequest:
3331             self._update(args,dict)
3332 
3333 
3334     def getfields(self):
3335         return self.__fields
3336 
3337 
3338     def _update(self, args, kwargs):
3339         super(setmoderequest,self)._update(args,kwargs)
3340         keys=kwargs.keys()
3341         for key in keys:
3342             if key in self.__fields:
3343                 setattr(self, key, kwargs[key])
3344                 del kwargs[key]
3345         # Were any unrecognized kwargs passed in?
3346         if __debug__:
3347             self._complainaboutunusedargs(setmoderequest,kwargs)
3348         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3349         # Make all P fields that haven't already been constructed
3350 
3351 
3352     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3353         'Writes this packet to the supplied buffer'
3354         self._bufferstartoffset=buf.getcurrentoffset()
3355         try: self.__field_command
3356         except:
3357             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
3358         self.__field_command.writetobuffer(buf)
3359         self.__field_request.writetobuffer(buf)
3360         try: self.__field_zero
3361         except:
3362             self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
3363         self.__field_zero.writetobuffer(buf)
3364         self._bufferendoffset=buf.getcurrentoffset()
3365         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3366 
3367 
3368     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3369         'Reads this packet from the supplied buffer'
3370         self._bufferstartoffset=buf.getcurrentoffset()
3371         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3372         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
3373         self.__field_command.readfrombuffer(buf)
3374         self.__field_request=UINT(**{'sizeinbytes': 1})
3375         self.__field_request.readfrombuffer(buf)
3376         self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
3377         self.__field_zero.readfrombuffer(buf)
3378         self._bufferendoffset=buf.getcurrentoffset()
3379 
3380 
3381     def __getfield_command(self):
3382         try: self.__field_command
3383         except:
3384             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
3385         return self.__field_command.getvalue()
3386 
3387     def __setfield_command(self, value):
3388         if isinstance(value,UINT):
3389             self.__field_command=value
3390         else:
3391             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x29})
3392 
3393     def __delfield_command(self): del self.__field_command
3394 
3395     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3396 
3397     def __getfield_request(self):
3398         return self.__field_request.getvalue()
3399 
3400     def __setfield_request(self, value):
3401         if isinstance(value,UINT):
3402             self.__field_request=value
3403         else:
3404             self.__field_request=UINT(value,**{'sizeinbytes': 1})
3405 
3406     def __delfield_request(self): del self.__field_request
3407 
3408     request=property(__getfield_request, __setfield_request, __delfield_request, "1=offline 2-reset.  Reset has no effect unless already offline")
3409 
3410     def __getfield_zero(self):
3411         try: self.__field_zero
3412         except:
3413             self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
3414         return self.__field_zero.getvalue()
3415 
3416     def __setfield_zero(self, value):
3417         if isinstance(value,UINT):
3418             self.__field_zero=value
3419         else:
3420             self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
3421 
3422     def __delfield_zero(self): del self.__field_zero
3423 
3424     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
3425 
3426     def iscontainer(self):
3427         return True
3428 
3429     def containerelements(self):
3430         yield ('command', self.__field_command, None)
3431         yield ('request', self.__field_request, "1=offline 2-reset.  Reset has no effect unless already offline")
3432         yield ('zero', self.__field_zero, None)
3433 
3434 
3435 
3436 
3437 class setmoderesponse(BaseProtogenClass):
3438     __fields=['pad']
3439 
3440     def __init__(self, *args, **kwargs):
3441         dict={}
3442         # What was supplied to this function
3443         dict.update(kwargs)
3444         # Parent constructor
3445         super(setmoderesponse,self).__init__(**dict)
3446         if self.__class__ is setmoderesponse:
3447             self._update(args,dict)
3448 
3449 
3450     def getfields(self):
3451         return self.__fields
3452 
3453 
3454     def _update(self, args, kwargs):
3455         super(setmoderesponse,self)._update(args,kwargs)
3456         keys=kwargs.keys()
3457         for key in keys:
3458             if key in self.__fields:
3459                 setattr(self, key, kwargs[key])
3460                 del kwargs[key]
3461         # Were any unrecognized kwargs passed in?
3462         if __debug__:
3463             self._complainaboutunusedargs(setmoderesponse,kwargs)
3464         if len(args):
3465             dict2={}
3466             dict2.update(kwargs)
3467             kwargs=dict2
3468             self.__field_pad=UNKNOWN(*args,**dict2)
3469         # Make all P fields that haven't already been constructed
3470 
3471 
3472     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3473         'Writes this packet to the supplied buffer'
3474         self._bufferstartoffset=buf.getcurrentoffset()
3475         self.__field_pad.writetobuffer(buf)
3476         self._bufferendoffset=buf.getcurrentoffset()
3477         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3478 
3479 
3480     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3481         'Reads this packet from the supplied buffer'
3482         self._bufferstartoffset=buf.getcurrentoffset()
3483         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3484         self.__field_pad=UNKNOWN()
3485         self.__field_pad.readfrombuffer(buf)
3486         self._bufferendoffset=buf.getcurrentoffset()
3487 
3488 
3489     def __getfield_pad(self):
3490         return self.__field_pad.getvalue()
3491 
3492     def __setfield_pad(self, value):
3493         if isinstance(value,UNKNOWN):
3494             self.__field_pad=value
3495         else:
3496             self.__field_pad=UNKNOWN(value,)
3497 
3498     def __delfield_pad(self): del self.__field_pad
3499 
3500     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3501 
3502     def iscontainer(self):
3503         return True
3504 
3505     def containerelements(self):
3506         yield ('pad', self.__field_pad, None)
3507 
3508 
3509 
3510 
3511 class setmodemmoderequest(BaseProtogenClass):
3512     __fields=['command']
3513 
3514     def __init__(self, *args, **kwargs):
3515         dict={}
3516         # What was supplied to this function
3517         dict.update(kwargs)
3518         # Parent constructor
3519         super(setmodemmoderequest,self).__init__(**dict)
3520         if self.__class__ is setmodemmoderequest:
3521             self._update(args,dict)
3522 
3523 
3524     def getfields(self):
3525         return self.__fields
3526 
3527 
3528     def _update(self, args, kwargs):
3529         super(setmodemmoderequest,self)._update(args,kwargs)
3530         keys=kwargs.keys()
3531         for key in keys:
3532             if key in self.__fields:
3533                 setattr(self, key, kwargs[key])
3534                 del kwargs[key]
3535         # Were any unrecognized kwargs passed in?
3536         if __debug__:
3537             self._complainaboutunusedargs(setmodemmoderequest,kwargs)
3538         if len(args):
3539             dict2={'sizeinbytes': 1, 'constant': 0x44}
3540             dict2.update(kwargs)
3541             kwargs=dict2
3542             self.__field_command=UINT(*args,**dict2)
3543         # Make all P fields that haven't already been constructed
3544 
3545 
3546     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3547         'Writes this packet to the supplied buffer'
3548         self._bufferstartoffset=buf.getcurrentoffset()
3549         try: self.__field_command
3550         except:
3551             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x44})
3552         self.__field_command.writetobuffer(buf)
3553         self._bufferendoffset=buf.getcurrentoffset()
3554         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3555 
3556 
3557     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3558         'Reads this packet from the supplied buffer'
3559         self._bufferstartoffset=buf.getcurrentoffset()
3560         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3561         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x44})
3562         self.__field_command.readfrombuffer(buf)
3563         self._bufferendoffset=buf.getcurrentoffset()
3564 
3565 
3566     def __getfield_command(self):
3567         try: self.__field_command
3568         except:
3569             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x44})
3570         return self.__field_command.getvalue()
3571 
3572     def __setfield_command(self, value):
3573         if isinstance(value,UINT):
3574             self.__field_command=value
3575         else:
3576             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x44})
3577 
3578     def __delfield_command(self): del self.__field_command
3579 
3580     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3581 
3582     def iscontainer(self):
3583         return True
3584 
3585     def containerelements(self):
3586         yield ('command', self.__field_command, None)
3587 
3588 
3589 
3590 
3591 class setfileattrrequest(BaseProtogenClass):
3592     "Set the attributes of the file"
3593     __fields=['header', 'unknown', 'date', 'filename']
3594 
3595     def __init__(self, *args, **kwargs):
3596         dict={}
3597         # What was supplied to this function
3598         dict.update(kwargs)
3599         # Parent constructor
3600         super(setfileattrrequest,self).__init__(**dict)
3601         if self.__class__ is setfileattrrequest:
3602             self._update(args,dict)
3603 
3604 
3605     def getfields(self):
3606         return self.__fields
3607 
3608 
3609     def _update(self, args, kwargs):
3610         super(setfileattrrequest,self)._update(args,kwargs)
3611         keys=kwargs.keys()
3612         for key in keys:
3613             if key in self.__fields:
3614                 setattr(self, key, kwargs[key])
3615                 del kwargs[key]
3616         # Were any unrecognized kwargs passed in?
3617         if __debug__:
3618             self._complainaboutunusedargs(setfileattrrequest,kwargs)
3619         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3620         # Make all P fields that haven't already been constructed
3621 
3622 
3623     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3624         'Writes this packet to the supplied buffer'
3625         self._bufferstartoffset=buf.getcurrentoffset()
3626         try: self.__field_header
3627         except:
3628             self.__field_header=requestheader(**{ 'command': 8 })
3629         self.__field_header.writetobuffer(buf)
3630         try: self.__field_unknown
3631         except:
3632             self.__field_unknown=UINT(**{'sizeinbytes': 4, 'constant': 0x000100ff})
3633         self.__field_unknown.writetobuffer(buf)
3634         self.__field_date.writetobuffer(buf)
3635         self.__field_filename.writetobuffer(buf)
3636         self._bufferendoffset=buf.getcurrentoffset()
3637         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3638 
3639 
3640     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3641         'Reads this packet from the supplied buffer'
3642         self._bufferstartoffset=buf.getcurrentoffset()
3643         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3644         self.__field_header=requestheader(**{ 'command': 8 })
3645         self.__field_header.readfrombuffer(buf)
3646         self.__field_unknown=UINT(**{'sizeinbytes': 4, 'constant': 0x000100ff})
3647         self.__field_unknown.readfrombuffer(buf)
3648         self.__field_date=UINT(**{'sizeinbytes': 4})
3649         self.__field_date.readfrombuffer(buf)
3650         self.__field_filename=USTRING(**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
3651         self.__field_filename.readfrombuffer(buf)
3652         self._bufferendoffset=buf.getcurrentoffset()
3653 
3654 
3655     def __getfield_header(self):
3656         try: self.__field_header
3657         except:
3658             self.__field_header=requestheader(**{ 'command': 8 })
3659         return self.__field_header.getvalue()
3660 
3661     def __setfield_header(self, value):
3662         if isinstance(value,requestheader):
3663             self.__field_header=value
3664         else:
3665             self.__field_header=requestheader(value,**{ 'command': 8 })
3666 
3667     def __delfield_header(self): del self.__field_header
3668 
3669     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3670 
3671     def __getfield_unknown(self):
3672         try: self.__field_unknown
3673         except:
3674             self.__field_unknown=UINT(**{'sizeinbytes': 4, 'constant': 0x000100ff})
3675         return self.__field_unknown.getvalue()
3676 
3677     def __setfield_unknown(self, value):
3678         if isinstance(value,UINT):
3679             self.__field_unknown=value
3680         else:
3681             self.__field_unknown=UINT(value,**{'sizeinbytes': 4, 'constant': 0x000100ff})
3682 
3683     def __delfield_unknown(self): del self.__field_unknown
3684 
3685     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, "probably file attributes")
3686 
3687     def __getfield_date(self):
3688         return self.__field_date.getvalue()
3689 
3690     def __setfield_date(self, value):
3691         if isinstance(value,UINT):
3692             self.__field_date=value
3693         else:
3694             self.__field_date=UINT(value,**{'sizeinbytes': 4})
3695 
3696     def __delfield_date(self): del self.__field_date
3697 
3698     date=property(__getfield_date, __setfield_date, __delfield_date, None)
3699 
3700     def __getfield_filename(self):
3701         return self.__field_filename.getvalue()
3702 
3703     def __setfield_filename(self, value):
3704         if isinstance(value,USTRING):
3705             self.__field_filename=value
3706         else:
3707             self.__field_filename=USTRING(value,**{'terminator': 0, 'pascal': True,               'encoding': PHONE_ENCODING })
3708 
3709     def __delfield_filename(self): del self.__field_filename
3710 
3711     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
3712 
3713     def iscontainer(self):
3714         return True
3715 
3716     def containerelements(self):
3717         yield ('header', self.__field_header, None)
3718         yield ('unknown', self.__field_unknown, "probably file attributes")
3719         yield ('date', self.__field_date, None)
3720         yield ('filename', self.__field_filename, None)
3721 
3722 
3723 
3724 
3725 class data(BaseProtogenClass):
3726     __fields=['bytes']
3727 
3728     def __init__(self, *args, **kwargs):
3729         dict={}
3730         # What was supplied to this function
3731         dict.update(kwargs)
3732         # Parent constructor
3733         super(data,self).__init__(**dict)
3734         if self.__class__ is data:
3735             self._update(args,dict)
3736 
3737 
3738     def getfields(self):
3739         return self.__fields
3740 
3741 
3742     def _update(self, args, kwargs):
3743         super(data,self)._update(args,kwargs)
3744         keys=kwargs.keys()
3745         for key in keys:
3746             if key in self.__fields:
3747                 setattr(self, key, kwargs[key])
3748                 del kwargs[key]
3749         # Were any unrecognized kwargs passed in?
3750         if __debug__:
3751             self._complainaboutunusedargs(data,kwargs)
3752         if len(args):
3753             dict2={}
3754             dict2.update(kwargs)
3755             kwargs=dict2
3756             self.__field_bytes=DATA(*args,**dict2)
3757         # Make all P fields that haven't already been constructed
3758 
3759 
3760     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3761         'Writes this packet to the supplied buffer'
3762         self._bufferstartoffset=buf.getcurrentoffset()
3763         self.__field_bytes.writetobuffer(buf)
3764         self._bufferendoffset=buf.getcurrentoffset()
3765         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3766 
3767 
3768     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3769         'Reads this packet from the supplied buffer'
3770         self._bufferstartoffset=buf.getcurrentoffset()
3771         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3772         self.__field_bytes=DATA()
3773         self.__field_bytes.readfrombuffer(buf)
3774         self._bufferendoffset=buf.getcurrentoffset()
3775 
3776 
3777     def __getfield_bytes(self):
3778         return self.__field_bytes.getvalue()
3779 
3780     def __setfield_bytes(self, value):
3781         if isinstance(value,DATA):
3782             self.__field_bytes=value
3783         else:
3784             self.__field_bytes=DATA(value,)
3785 
3786     def __delfield_bytes(self): del self.__field_bytes
3787 
3788     bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
3789 
3790     def iscontainer(self):
3791         return True
3792 
3793     def containerelements(self):
3794         yield ('bytes', self.__field_bytes, None)
3795 
3796 
3797 
3798 
3799 class new_requestheader(BaseProtogenClass):
3800     "The bit in front on all Brew request packets"
3801     __fields=['commandmode', 'command', 'zero']
3802 
3803     def __init__(self, *args, **kwargs):
3804         dict={}
3805         # What was supplied to this function
3806         dict.update(kwargs)
3807         # Parent constructor
3808         super(new_requestheader,self).__init__(**dict)
3809         if self.__class__ is new_requestheader:
3810             self._update(args,dict)
3811 
3812 
3813     def getfields(self):
3814         return self.__fields
3815 
3816 
3817     def _update(self, args, kwargs):
3818         super(new_requestheader,self)._update(args,kwargs)
3819         keys=kwargs.keys()
3820         for key in keys:
3821             if key in self.__fields:
3822                 setattr(self, key, kwargs[key])
3823                 del kwargs[key]
3824         # Were any unrecognized kwargs passed in?
3825         if __debug__:
3826             self._complainaboutunusedargs(new_requestheader,kwargs)
3827         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3828         # Make all P fields that haven't already been constructed
3829 
3830 
3831     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3832         'Writes this packet to the supplied buffer'
3833         self._bufferstartoffset=buf.getcurrentoffset()
3834         try: self.__field_commandmode
3835         except:
3836             self.__field_commandmode=UINT(**{'sizeinbytes': 2, 'constant': 0x134B})
3837         self.__field_commandmode.writetobuffer(buf)
3838         self.__field_command.writetobuffer(buf)
3839         try: self.__field_zero
3840         except:
3841             self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
3842         self.__field_zero.writetobuffer(buf)
3843         self._bufferendoffset=buf.getcurrentoffset()
3844         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3845 
3846 
3847     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3848         'Reads this packet from the supplied buffer'
3849         self._bufferstartoffset=buf.getcurrentoffset()
3850         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3851         self.__field_commandmode=UINT(**{'sizeinbytes': 2, 'constant': 0x134B})
3852         self.__field_commandmode.readfrombuffer(buf)
3853         self.__field_command=UINT(**{'sizeinbytes': 1})
3854         self.__field_command.readfrombuffer(buf)
3855         self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
3856         self.__field_zero.readfrombuffer(buf)
3857         self._bufferendoffset=buf.getcurrentoffset()
3858 
3859 
3860     def __getfield_commandmode(self):
3861         try: self.__field_commandmode
3862         except:
3863             self.__field_commandmode=UINT(**{'sizeinbytes': 2, 'constant': 0x134B})
3864         return self.__field_commandmode.getvalue()
3865 
3866     def __setfield_commandmode(self, value):
3867         if isinstance(value,UINT):
3868             self.__field_commandmode=value
3869         else:
3870             self.__field_commandmode=UINT(value,**{'sizeinbytes': 2, 'constant': 0x134B})
3871 
3872     def __delfield_commandmode(self): del self.__field_commandmode
3873 
3874     commandmode=property(__getfield_commandmode, __setfield_commandmode, __delfield_commandmode, None)
3875 
3876     def __getfield_command(self):
3877         return self.__field_command.getvalue()
3878 
3879     def __setfield_command(self, value):
3880         if isinstance(value,UINT):
3881             self.__field_command=value
3882         else:
3883             self.__field_command=UINT(value,**{'sizeinbytes': 1})
3884 
3885     def __delfield_command(self): del self.__field_command
3886 
3887     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3888 
3889     def __getfield_zero(self):
3890         try: self.__field_zero
3891         except:
3892             self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
3893         return self.__field_zero.getvalue()
3894 
3895     def __setfield_zero(self, value):
3896         if isinstance(value,UINT):
3897             self.__field_zero=value
3898         else:
3899             self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'constant': 0})
3900 
3901     def __delfield_zero(self): del self.__field_zero
3902 
3903     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
3904 
3905     def iscontainer(self):
3906         return True
3907 
3908     def containerelements(self):
3909         yield ('commandmode', self.__field_commandmode, None)
3910         yield ('command', self.__field_command, None)
3911         yield ('zero', self.__field_zero, None)
3912 
3913 
3914 
3915 
3916 class new_responseheader(BaseProtogenClass):
3917     "The bit in front on all Brew response packets"
3918     __fields=['commandmode', 'command', 'zero']
3919 
3920     def __init__(self, *args, **kwargs):
3921         dict={}
3922         # What was supplied to this function
3923         dict.update(kwargs)
3924         # Parent constructor
3925         super(new_responseheader,self).__init__(**dict)
3926         if self.__class__ is new_responseheader:
3927             self._update(args,dict)
3928 
3929 
3930     def getfields(self):
3931         return self.__fields
3932 
3933 
3934     def _update(self, args, kwargs):
3935         super(new_responseheader,self)._update(args,kwargs)
3936         keys=kwargs.keys()
3937         for key in keys:
3938             if key in self.__fields:
3939                 setattr(self, key, kwargs[key])
3940                 del kwargs[key]
3941         # Were any unrecognized kwargs passed in?
3942         if __debug__:
3943             self._complainaboutunusedargs(new_responseheader,kwargs)
3944         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3945         # Make all P fields that haven't already been constructed
3946 
3947 
3948     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3949         'Writes this packet to the supplied buffer'
3950         self._bufferstartoffset=buf.getcurrentoffset()
3951         self.__field_commandmode.writetobuffer(buf)
3952         self.__field_command.writetobuffer(buf)
3953         self.__field_zero.writetobuffer(buf)
3954         self._bufferendoffset=buf.getcurrentoffset()
3955         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3956 
3957 
3958     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3959         'Reads this packet from the supplied buffer'
3960         self._bufferstartoffset=buf.getcurrentoffset()
3961         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3962         self.__field_commandmode=UINT(**{'sizeinbytes': 2, 'constant': 0x134B})
3963         self.__field_commandmode.readfrombuffer(buf)
3964         self.__field_command=UINT(**{'sizeinbytes': 1})
3965         self.__field_command.readfrombuffer(buf)
3966         self.__field_zero=UINT(**{'sizeinbytes': 1})
3967         self.__field_zero.readfrombuffer(buf)
3968         self._bufferendoffset=buf.getcurrentoffset()
3969 
3970 
3971     def __getfield_commandmode(self):
3972         return self.__field_commandmode.getvalue()
3973 
3974     def __setfield_commandmode(self, value):
3975         if isinstance(value,UINT):
3976             self.__field_commandmode=value
3977         else:
3978             self.__field_commandmode=UINT(value,**{'sizeinbytes': 2, 'constant': 0x134B})
3979 
3980     def __delfield_commandmode(self): del self.__field_commandmode
3981 
3982     commandmode=property(__getfield_commandmode, __setfield_commandmode, __delfield_commandmode, None)
3983 
3984     def __getfield_command(self):
3985         return self.__field_command.getvalue()
3986 
3987     def __setfield_command(self, value):
3988         if isinstance(value,UINT):
3989             self.__field_command=value
3990         else:
3991             self.__field_command=UINT(value,**{'sizeinbytes': 1})
3992 
3993     def __delfield_command(self): del self.__field_command
3994 
3995     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3996 
3997     def __getfield_zero(self):
3998         return self.__field_zero.getvalue()
3999 
4000     def __setfield_zero(self, value):
4001         if isinstance(value,UINT):
4002             self.__field_zero=value
4003         else:
4004             self.__field_zero=UINT(value,**{'sizeinbytes': 1})
4005 
4006     def __delfield_zero(self): del self.__field_zero
4007 
4008     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
4009 
4010     def iscontainer(self):
4011         return True
4012 
4013     def containerelements(self):
4014         yield ('commandmode', self.__field_commandmode, None)
4015         yield ('command', self.__field_command, None)
4016         yield ('zero', self.__field_zero, None)
4017 
4018 
4019 
4020 
4021 class new_openfilerequest(BaseProtogenClass):
4022     __fields=['header', 'mode', 'flags', 'filename']
4023 
4024     def __init__(self, *args, **kwargs):
4025         dict={}
4026         # What was supplied to this function
4027         dict.update(kwargs)
4028         # Parent constructor
4029         super(new_openfilerequest,self).__init__(**dict)
4030         if self.__class__ is new_openfilerequest:
4031             self._update(args,dict)
4032 
4033 
4034     def getfields(self):
4035         return self.__fields
4036 
4037 
4038     def _update(self, args, kwargs):
4039         super(new_openfilerequest,self)._update(args,kwargs)
4040         keys=kwargs.keys()
4041         for key in keys:
4042             if key in self.__fields:
4043                 setattr(self, key, kwargs[key])
4044                 del kwargs[key]
4045         # Were any unrecognized kwargs passed in?
4046         if __debug__:
4047             self._complainaboutunusedargs(new_openfilerequest,kwargs)
4048         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4049         # Make all P fields that haven't already been constructed
4050 
4051 
4052     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4053         'Writes this packet to the supplied buffer'
4054         self._bufferstartoffset=buf.getcurrentoffset()
4055         try: self.__field_header
4056         except:
4057             self.__field_header=new_requestheader(**{'command': 0x02})
4058         self.__field_header.writetobuffer(buf)
4059         self.__field_mode.writetobuffer(buf)
4060         self.__field_flags.writetobuffer(buf)
4061         self.__field_filename.writetobuffer(buf)
4062         self._bufferendoffset=buf.getcurrentoffset()
4063         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4064 
4065 
4066     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4067         'Reads this packet from the supplied buffer'
4068         self._bufferstartoffset=buf.getcurrentoffset()
4069         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4070         self.__field_header=new_requestheader(**{'command': 0x02})
4071         self.__field_header.readfrombuffer(buf)
4072         self.__field_mode=UINT(**{'sizeinbytes': 4})
4073         self.__field_mode.readfrombuffer(buf)
4074         self.__field_flags=UINT(**{'sizeinbytes': 4})
4075         self.__field_flags.readfrombuffer(buf)
4076         self.__field_filename=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
4077         self.__field_filename.readfrombuffer(buf)
4078         self._bufferendoffset=buf.getcurrentoffset()
4079 
4080 
4081     def __getfield_header(self):
4082         try: self.__field_header
4083         except:
4084             self.__field_header=new_requestheader(**{'command': 0x02})
4085         return self.__field_header.getvalue()
4086 
4087     def __setfield_header(self, value):
4088         if isinstance(value,new_requestheader):
4089             self.__field_header=value
4090         else:
4091             self.__field_header=new_requestheader(value,**{'command': 0x02})
4092 
4093     def __delfield_header(self): del self.__field_header
4094 
4095     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4096 
4097     def __getfield_mode(self):
4098         return self.__field_mode.getvalue()
4099 
4100     def __setfield_mode(self, value):
4101         if isinstance(value,UINT):
4102             self.__field_mode=value
4103         else:
4104             self.__field_mode=UINT(value,**{'sizeinbytes': 4})
4105 
4106     def __delfield_mode(self): del self.__field_mode
4107 
4108     mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None)
4109 
4110     def __getfield_flags(self):
4111         return self.__field_flags.getvalue()
4112 
4113     def __setfield_flags(self, value):
4114         if isinstance(value,UINT):
4115             self.__field_flags=value
4116         else:
4117             self.__field_flags=UINT(value,**{'sizeinbytes': 4})
4118 
4119     def __delfield_flags(self): del self.__field_flags
4120 
4121     flags=property(__getfield_flags, __setfield_flags, __delfield_flags, None)
4122 
4123     def __getfield_filename(self):
4124         return self.__field_filename.getvalue()
4125 
4126     def __setfield_filename(self, value):
4127         if isinstance(value,USTRING):
4128             self.__field_filename=value
4129         else:
4130             self.__field_filename=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
4131 
4132     def __delfield_filename(self): del self.__field_filename
4133 
4134     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
4135 
4136     def iscontainer(self):
4137         return True
4138 
4139     def containerelements(self):
4140         yield ('header', self.__field_header, None)
4141         yield ('mode', self.__field_mode, None)
4142         yield ('flags', self.__field_flags, None)
4143         yield ('filename', self.__field_filename, None)
4144 
4145 
4146 
4147 
4148 class new_openfileresponse(BaseProtogenClass):
4149     __fields=['header', 'handle', 'error']
4150 
4151     def __init__(self, *args, **kwargs):
4152         dict={}
4153         # What was supplied to this function
4154         dict.update(kwargs)
4155         # Parent constructor
4156         super(new_openfileresponse,self).__init__(**dict)
4157         if self.__class__ is new_openfileresponse:
4158             self._update(args,dict)
4159 
4160 
4161     def getfields(self):
4162         return self.__fields
4163 
4164 
4165     def _update(self, args, kwargs):
4166         super(new_openfileresponse,self)._update(args,kwargs)
4167         keys=kwargs.keys()
4168         for key in keys:
4169             if key in self.__fields:
4170                 setattr(self, key, kwargs[key])
4171                 del kwargs[key]
4172         # Were any unrecognized kwargs passed in?
4173         if __debug__:
4174             self._complainaboutunusedargs(new_openfileresponse,kwargs)
4175         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4176         # Make all P fields that haven't already been constructed
4177 
4178 
4179     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4180         'Writes this packet to the supplied buffer'
4181         self._bufferstartoffset=buf.getcurrentoffset()
4182         self.__field_header.writetobuffer(buf)
4183         self.__field_handle.writetobuffer(buf)
4184         self.__field_error.writetobuffer(buf)
4185         self._bufferendoffset=buf.getcurrentoffset()
4186         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4187 
4188 
4189     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4190         'Reads this packet from the supplied buffer'
4191         self._bufferstartoffset=buf.getcurrentoffset()
4192         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4193         self.__field_header=new_responseheader()
4194         self.__field_header.readfrombuffer(buf)
4195         self.__field_handle=UINT(**{'sizeinbytes': 4})
4196         self.__field_handle.readfrombuffer(buf)
4197         self.__field_error=UINT(**{'sizeinbytes': 4})
4198         self.__field_error.readfrombuffer(buf)
4199         self._bufferendoffset=buf.getcurrentoffset()
4200 
4201 
4202     def __getfield_header(self):
4203         return self.__field_header.getvalue()
4204 
4205     def __setfield_header(self, value):
4206         if isinstance(value,new_responseheader):
4207             self.__field_header=value
4208         else:
4209             self.__field_header=new_responseheader(value,)
4210 
4211     def __delfield_header(self): del self.__field_header
4212 
4213     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4214 
4215     def __getfield_handle(self):
4216         return self.__field_handle.getvalue()
4217 
4218     def __setfield_handle(self, value):
4219         if isinstance(value,UINT):
4220             self.__field_handle=value
4221         else:
4222             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
4223 
4224     def __delfield_handle(self): del self.__field_handle
4225 
4226     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
4227 
4228     def __getfield_error(self):
4229         return self.__field_error.getvalue()
4230 
4231     def __setfield_error(self, value):
4232         if isinstance(value,UINT):
4233             self.__field_error=value
4234         else:
4235             self.__field_error=UINT(value,**{'sizeinbytes': 4})
4236 
4237     def __delfield_error(self): del self.__field_error
4238 
4239     error=property(__getfield_error, __setfield_error, __delfield_error, None)
4240 
4241     def iscontainer(self):
4242         return True
4243 
4244     def containerelements(self):
4245         yield ('header', self.__field_header, None)
4246         yield ('handle', self.__field_handle, None)
4247         yield ('error', self.__field_error, None)
4248 
4249 
4250 
4251 
4252 class new_closefilerequest(BaseProtogenClass):
4253     __fields=['header', 'handle']
4254 
4255     def __init__(self, *args, **kwargs):
4256         dict={}
4257         # What was supplied to this function
4258         dict.update(kwargs)
4259         # Parent constructor
4260         super(new_closefilerequest,self).__init__(**dict)
4261         if self.__class__ is new_closefilerequest:
4262             self._update(args,dict)
4263 
4264 
4265     def getfields(self):
4266         return self.__fields
4267 
4268 
4269     def _update(self, args, kwargs):
4270         super(new_closefilerequest,self)._update(args,kwargs)
4271         keys=kwargs.keys()
4272         for key in keys:
4273             if key in self.__fields:
4274                 setattr(self, key, kwargs[key])
4275                 del kwargs[key]
4276         # Were any unrecognized kwargs passed in?
4277         if __debug__:
4278             self._complainaboutunusedargs(new_closefilerequest,kwargs)
4279         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4280         # Make all P fields that haven't already been constructed
4281 
4282 
4283     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4284         'Writes this packet to the supplied buffer'
4285         self._bufferstartoffset=buf.getcurrentoffset()
4286         try: self.__field_header
4287         except:
4288             self.__field_header=new_requestheader(**{'command': 0x03})
4289         self.__field_header.writetobuffer(buf)
4290         self.__field_handle.writetobuffer(buf)
4291         self._bufferendoffset=buf.getcurrentoffset()
4292         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4293 
4294 
4295     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4296         'Reads this packet from the supplied buffer'
4297         self._bufferstartoffset=buf.getcurrentoffset()
4298         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4299         self.__field_header=new_requestheader(**{'command': 0x03})
4300         self.__field_header.readfrombuffer(buf)
4301         self.__field_handle=UINT(**{'sizeinbytes': 4})
4302         self.__field_handle.readfrombuffer(buf)
4303         self._bufferendoffset=buf.getcurrentoffset()
4304 
4305 
4306     def __getfield_header(self):
4307         try: self.__field_header
4308         except:
4309             self.__field_header=new_requestheader(**{'command': 0x03})
4310         return self.__field_header.getvalue()
4311 
4312     def __setfield_header(self, value):
4313         if isinstance(value,new_requestheader):
4314             self.__field_header=value
4315         else:
4316             self.__field_header=new_requestheader(value,**{'command': 0x03})
4317 
4318     def __delfield_header(self): del self.__field_header
4319 
4320     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4321 
4322     def __getfield_handle(self):
4323         return self.__field_handle.getvalue()
4324 
4325     def __setfield_handle(self, value):
4326         if isinstance(value,UINT):
4327             self.__field_handle=value
4328         else:
4329             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
4330 
4331     def __delfield_handle(self): del self.__field_handle
4332 
4333     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
4334 
4335     def iscontainer(self):
4336         return True
4337 
4338     def containerelements(self):
4339         yield ('header', self.__field_header, None)
4340         yield ('handle', self.__field_handle, None)
4341 
4342 
4343 
4344 
4345 class new_closefileresponse(BaseProtogenClass):
4346     __fields=['header', 'error']
4347 
4348     def __init__(self, *args, **kwargs):
4349         dict={}
4350         # What was supplied to this function
4351         dict.update(kwargs)
4352         # Parent constructor
4353         super(new_closefileresponse,self).__init__(**dict)
4354         if self.__class__ is new_closefileresponse:
4355             self._update(args,dict)
4356 
4357 
4358     def getfields(self):
4359         return self.__fields
4360 
4361 
4362     def _update(self, args, kwargs):
4363         super(new_closefileresponse,self)._update(args,kwargs)
4364         keys=kwargs.keys()
4365         for key in keys:
4366             if key in self.__fields:
4367                 setattr(self, key, kwargs[key])
4368                 del kwargs[key]
4369         # Were any unrecognized kwargs passed in?
4370         if __debug__:
4371             self._complainaboutunusedargs(new_closefileresponse,kwargs)
4372         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4373         # Make all P fields that haven't already been constructed
4374 
4375 
4376     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4377         'Writes this packet to the supplied buffer'
4378         self._bufferstartoffset=buf.getcurrentoffset()
4379         self.__field_header.writetobuffer(buf)
4380         self.__field_error.writetobuffer(buf)
4381         self._bufferendoffset=buf.getcurrentoffset()
4382         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4383 
4384 
4385     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4386         'Reads this packet from the supplied buffer'
4387         self._bufferstartoffset=buf.getcurrentoffset()
4388         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4389         self.__field_header=new_responseheader()
4390         self.__field_header.readfrombuffer(buf)
4391         self.__field_error=UINT(**{'sizeinbytes': 4})
4392         self.__field_error.readfrombuffer(buf)
4393         self._bufferendoffset=buf.getcurrentoffset()
4394 
4395 
4396     def __getfield_header(self):
4397         return self.__field_header.getvalue()
4398 
4399     def __setfield_header(self, value):
4400         if isinstance(value,new_responseheader):
4401             self.__field_header=value
4402         else:
4403             self.__field_header=new_responseheader(value,)
4404 
4405     def __delfield_header(self): del self.__field_header
4406 
4407     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4408 
4409     def __getfield_error(self):
4410         return self.__field_error.getvalue()
4411 
4412     def __setfield_error(self, value):
4413         if isinstance(value,UINT):
4414             self.__field_error=value
4415         else:
4416             self.__field_error=UINT(value,**{'sizeinbytes': 4})
4417 
4418     def __delfield_error(self): del self.__field_error
4419 
4420     error=property(__getfield_error, __setfield_error, __delfield_error, None)
4421 
4422     def iscontainer(self):
4423         return True
4424 
4425     def containerelements(self):
4426         yield ('header', self.__field_header, None)
4427         yield ('error', self.__field_error, None)
4428 
4429 
4430 
4431 
4432 class new_readfilerequest(BaseProtogenClass):
4433     __fields=['header', 'handle', 'bytes', 'position']
4434 
4435     def __init__(self, *args, **kwargs):
4436         dict={}
4437         # What was supplied to this function
4438         dict.update(kwargs)
4439         # Parent constructor
4440         super(new_readfilerequest,self).__init__(**dict)
4441         if self.__class__ is new_readfilerequest:
4442             self._update(args,dict)
4443 
4444 
4445     def getfields(self):
4446         return self.__fields
4447 
4448 
4449     def _update(self, args, kwargs):
4450         super(new_readfilerequest,self)._update(args,kwargs)
4451         keys=kwargs.keys()
4452         for key in keys:
4453             if key in self.__fields:
4454                 setattr(self, key, kwargs[key])
4455                 del kwargs[key]
4456         # Were any unrecognized kwargs passed in?
4457         if __debug__:
4458             self._complainaboutunusedargs(new_readfilerequest,kwargs)
4459         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4460         # Make all P fields that haven't already been constructed
4461 
4462 
4463     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4464         'Writes this packet to the supplied buffer'
4465         self._bufferstartoffset=buf.getcurrentoffset()
4466         try: self.__field_header
4467         except:
4468             self.__field_header=new_requestheader(**{'command': 0x04})
4469         self.__field_header.writetobuffer(buf)
4470         self.__field_handle.writetobuffer(buf)
4471         self.__field_bytes.writetobuffer(buf)
4472         self.__field_position.writetobuffer(buf)
4473         self._bufferendoffset=buf.getcurrentoffset()
4474         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4475 
4476 
4477     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4478         'Reads this packet from the supplied buffer'
4479         self._bufferstartoffset=buf.getcurrentoffset()
4480         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4481         self.__field_header=new_requestheader(**{'command': 0x04})
4482         self.__field_header.readfrombuffer(buf)
4483         self.__field_handle=UINT(**{'sizeinbytes': 4})
4484         self.__field_handle.readfrombuffer(buf)
4485         self.__field_bytes=UINT(**{'sizeinbytes': 4})
4486         self.__field_bytes.readfrombuffer(buf)
4487         self.__field_position=UINT(**{'sizeinbytes': 4})
4488         self.__field_position.readfrombuffer(buf)
4489         self._bufferendoffset=buf.getcurrentoffset()
4490 
4491 
4492     def __getfield_header(self):
4493         try: self.__field_header
4494         except:
4495             self.__field_header=new_requestheader(**{'command': 0x04})
4496         return self.__field_header.getvalue()
4497 
4498     def __setfield_header(self, value):
4499         if isinstance(value,new_requestheader):
4500             self.__field_header=value
4501         else:
4502             self.__field_header=new_requestheader(value,**{'command': 0x04})
4503 
4504     def __delfield_header(self): del self.__field_header
4505 
4506     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4507 
4508     def __getfield_handle(self):
4509         return self.__field_handle.getvalue()
4510 
4511     def __setfield_handle(self, value):
4512         if isinstance(value,UINT):
4513             self.__field_handle=value
4514         else:
4515             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
4516 
4517     def __delfield_handle(self): del self.__field_handle
4518 
4519     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
4520 
4521     def __getfield_bytes(self):
4522         return self.__field_bytes.getvalue()
4523 
4524     def __setfield_bytes(self, value):
4525         if isinstance(value,UINT):
4526             self.__field_bytes=value
4527         else:
4528             self.__field_bytes=UINT(value,**{'sizeinbytes': 4})
4529 
4530     def __delfield_bytes(self): del self.__field_bytes
4531 
4532     bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
4533 
4534     def __getfield_position(self):
4535         return self.__field_position.getvalue()
4536 
4537     def __setfield_position(self, value):
4538         if isinstance(value,UINT):
4539             self.__field_position=value
4540         else:
4541             self.__field_position=UINT(value,**{'sizeinbytes': 4})
4542 
4543     def __delfield_position(self): del self.__field_position
4544 
4545     position=property(__getfield_position, __setfield_position, __delfield_position, None)
4546 
4547     def iscontainer(self):
4548         return True
4549 
4550     def containerelements(self):
4551         yield ('header', self.__field_header, None)
4552         yield ('handle', self.__field_handle, None)
4553         yield ('bytes', self.__field_bytes, None)
4554         yield ('position', self.__field_position, None)
4555 
4556 
4557 
4558 
4559 class new_readfileresponse(BaseProtogenClass):
4560     __fields=['header', 'handle', 'position', 'bytes', 'error', 'data']
4561 
4562     def __init__(self, *args, **kwargs):
4563         dict={}
4564         # What was supplied to this function
4565         dict.update(kwargs)
4566         # Parent constructor
4567         super(new_readfileresponse,self).__init__(**dict)
4568         if self.__class__ is new_readfileresponse:
4569             self._update(args,dict)
4570 
4571 
4572     def getfields(self):
4573         return self.__fields
4574 
4575 
4576     def _update(self, args, kwargs):
4577         super(new_readfileresponse,self)._update(args,kwargs)
4578         keys=kwargs.keys()
4579         for key in keys:
4580             if key in self.__fields:
4581                 setattr(self, key, kwargs[key])
4582                 del kwargs[key]
4583         # Were any unrecognized kwargs passed in?
4584         if __debug__:
4585             self._complainaboutunusedargs(new_readfileresponse,kwargs)
4586         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4587         # Make all P fields that haven't already been constructed
4588 
4589 
4590     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4591         'Writes this packet to the supplied buffer'
4592         self._bufferstartoffset=buf.getcurrentoffset()
4593         self.__field_header.writetobuffer(buf)
4594         self.__field_handle.writetobuffer(buf)
4595         self.__field_position.writetobuffer(buf)
4596         self.__field_bytes.writetobuffer(buf)
4597         self.__field_error.writetobuffer(buf)
4598         self.__field_data.writetobuffer(buf)
4599         self._bufferendoffset=buf.getcurrentoffset()
4600         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4601 
4602 
4603     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4604         'Reads this packet from the supplied buffer'
4605         self._bufferstartoffset=buf.getcurrentoffset()
4606         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4607         self.__field_header=new_responseheader()
4608         self.__field_header.readfrombuffer(buf)
4609         self.__field_handle=UINT(**{'sizeinbytes': 4})
4610         self.__field_handle.readfrombuffer(buf)
4611         self.__field_position=UINT(**{'sizeinbytes': 4})
4612         self.__field_position.readfrombuffer(buf)
4613         self.__field_bytes=UINT(**{'sizeinbytes': 4})
4614         self.__field_bytes.readfrombuffer(buf)
4615         self.__field_error=UINT(**{'sizeinbytes': 4})
4616         self.__field_error.readfrombuffer(buf)
4617         self.__field_data=DATA(**{'sizeinbytes': self.bytes})
4618         self.__field_data.readfrombuffer(buf)
4619         self._bufferendoffset=buf.getcurrentoffset()
4620 
4621 
4622     def __getfield_header(self):
4623         return self.__field_header.getvalue()
4624 
4625     def __setfield_header(self, value):
4626         if isinstance(value,new_responseheader):
4627             self.__field_header=value
4628         else:
4629             self.__field_header=new_responseheader(value,)
4630 
4631     def __delfield_header(self): del self.__field_header
4632 
4633     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4634 
4635     def __getfield_handle(self):
4636         return self.__field_handle.getvalue()
4637 
4638     def __setfield_handle(self, value):
4639         if isinstance(value,UINT):
4640             self.__field_handle=value
4641         else:
4642             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
4643 
4644     def __delfield_handle(self): del self.__field_handle
4645 
4646     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
4647 
4648     def __getfield_position(self):
4649         return self.__field_position.getvalue()
4650 
4651     def __setfield_position(self, value):
4652         if isinstance(value,UINT):
4653             self.__field_position=value
4654         else:
4655             self.__field_position=UINT(value,**{'sizeinbytes': 4})
4656 
4657     def __delfield_position(self): del self.__field_position
4658 
4659     position=property(__getfield_position, __setfield_position, __delfield_position, None)
4660 
4661     def __getfield_bytes(self):
4662         return self.__field_bytes.getvalue()
4663 
4664     def __setfield_bytes(self, value):
4665         if isinstance(value,UINT):
4666             self.__field_bytes=value
4667         else:
4668             self.__field_bytes=UINT(value,**{'sizeinbytes': 4})
4669 
4670     def __delfield_bytes(self): del self.__field_bytes
4671 
4672     bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
4673 
4674     def __getfield_error(self):
4675         return self.__field_error.getvalue()
4676 
4677     def __setfield_error(self, value):
4678         if isinstance(value,UINT):
4679             self.__field_error=value
4680         else:
4681             self.__field_error=UINT(value,**{'sizeinbytes': 4})
4682 
4683     def __delfield_error(self): del self.__field_error
4684 
4685     error=property(__getfield_error, __setfield_error, __delfield_error, None)
4686 
4687     def __getfield_data(self):
4688         return self.__field_data.getvalue()
4689 
4690     def __setfield_data(self, value):
4691         if isinstance(value,DATA):
4692             self.__field_data=value
4693         else:
4694             self.__field_data=DATA(value,**{'sizeinbytes': self.bytes})
4695 
4696     def __delfield_data(self): del self.__field_data
4697 
4698     data=property(__getfield_data, __setfield_data, __delfield_data, None)
4699 
4700     def iscontainer(self):
4701         return True
4702 
4703     def containerelements(self):
4704         yield ('header', self.__field_header, None)
4705         yield ('handle', self.__field_handle, None)
4706         yield ('position', self.__field_position, None)
4707         yield ('bytes', self.__field_bytes, None)
4708         yield ('error', self.__field_error, None)
4709         yield ('data', self.__field_data, None)
4710 
4711 
4712 
4713 
4714 class new_writefilerequest(BaseProtogenClass):
4715     __fields=['header', 'handle', 'position', 'bytes', 'data']
4716 
4717     def __init__(self, *args, **kwargs):
4718         dict={}
4719         # What was supplied to this function
4720         dict.update(kwargs)
4721         # Parent constructor
4722         super(new_writefilerequest,self).__init__(**dict)
4723         if self.__class__ is new_writefilerequest:
4724             self._update(args,dict)
4725 
4726 
4727     def getfields(self):
4728         return self.__fields
4729 
4730 
4731     def _update(self, args, kwargs):
4732         super(new_writefilerequest,self)._update(args,kwargs)
4733         keys=kwargs.keys()
4734         for key in keys:
4735             if key in self.__fields:
4736                 setattr(self, key, kwargs[key])
4737                 del kwargs[key]
4738         # Were any unrecognized kwargs passed in?
4739         if __debug__:
4740             self._complainaboutunusedargs(new_writefilerequest,kwargs)
4741         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4742         # Make all P fields that haven't already been constructed
4743         try: self.__field_bytes
4744         except:
4745             self.__field_bytes=UINT()
4746 
4747 
4748     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4749         'Writes this packet to the supplied buffer'
4750         self._bufferstartoffset=buf.getcurrentoffset()
4751         try: self.__field_header
4752         except:
4753             self.__field_header=new_requestheader(**{'command': 0x05})
4754         self.__field_header.writetobuffer(buf)
4755         self.__field_handle.writetobuffer(buf)
4756         self.__field_position.writetobuffer(buf)
4757         self.__field_data.writetobuffer(buf)
4758         self._bufferendoffset=buf.getcurrentoffset()
4759         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4760 
4761 
4762     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4763         'Reads this packet from the supplied buffer'
4764         self._bufferstartoffset=buf.getcurrentoffset()
4765         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4766         self.__field_header=new_requestheader(**{'command': 0x05})
4767         self.__field_header.readfrombuffer(buf)
4768         self.__field_handle=UINT(**{'sizeinbytes': 4})
4769         self.__field_handle.readfrombuffer(buf)
4770         self.__field_position=UINT(**{'sizeinbytes': 4})
4771         self.__field_position.readfrombuffer(buf)
4772         self.__field_data=DATA(**{'sizeinbytes': self.bytes})
4773         self.__field_data.readfrombuffer(buf)
4774         self._bufferendoffset=buf.getcurrentoffset()
4775 
4776 
4777     def __getfield_header(self):
4778         try: self.__field_header
4779         except:
4780             self.__field_header=new_requestheader(**{'command': 0x05})
4781         return self.__field_header.getvalue()
4782 
4783     def __setfield_header(self, value):
4784         if isinstance(value,new_requestheader):
4785             self.__field_header=value
4786         else:
4787             self.__field_header=new_requestheader(value,**{'command': 0x05})
4788 
4789     def __delfield_header(self): del self.__field_header
4790 
4791     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4792 
4793     def __getfield_handle(self):
4794         return self.__field_handle.getvalue()
4795 
4796     def __setfield_handle(self, value):
4797         if isinstance(value,UINT):
4798             self.__field_handle=value
4799         else:
4800             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
4801 
4802     def __delfield_handle(self): del self.__field_handle
4803 
4804     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
4805 
4806     def __getfield_position(self):
4807         return self.__field_position.getvalue()
4808 
4809     def __setfield_position(self, value):
4810         if isinstance(value,UINT):
4811             self.__field_position=value
4812         else:
4813             self.__field_position=UINT(value,**{'sizeinbytes': 4})
4814 
4815     def __delfield_position(self): del self.__field_position
4816 
4817     position=property(__getfield_position, __setfield_position, __delfield_position, None)
4818 
4819     def __getfield_bytes(self):
4820         return self.__field_bytes.getvalue()
4821 
4822     def __setfield_bytes(self, value):
4823         if isinstance(value,UINT):
4824             self.__field_bytes=value
4825         else:
4826             self.__field_bytes=UINT(value,)
4827 
4828     def __delfield_bytes(self): del self.__field_bytes
4829 
4830     bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
4831 
4832     def __getfield_data(self):
4833         return self.__field_data.getvalue()
4834 
4835     def __setfield_data(self, value):
4836         if isinstance(value,DATA):
4837             self.__field_data=value
4838         else:
4839             self.__field_data=DATA(value,**{'sizeinbytes': self.bytes})
4840 
4841     def __delfield_data(self): del self.__field_data
4842 
4843     data=property(__getfield_data, __setfield_data, __delfield_data, None)
4844 
4845     def iscontainer(self):
4846         return True
4847 
4848     def containerelements(self):
4849         yield ('header', self.__field_header, None)
4850         yield ('handle', self.__field_handle, None)
4851         yield ('position', self.__field_position, None)
4852         yield ('bytes', self.__field_bytes, None)
4853         yield ('data', self.__field_data, None)
4854 
4855 
4856 
4857 
4858 class new_writefileresponse(BaseProtogenClass):
4859     __fields=['header', 'handle', 'position', 'bytes', 'error']
4860 
4861     def __init__(self, *args, **kwargs):
4862         dict={}
4863         # What was supplied to this function
4864         dict.update(kwargs)
4865         # Parent constructor
4866         super(new_writefileresponse,self).__init__(**dict)
4867         if self.__class__ is new_writefileresponse:
4868             self._update(args,dict)
4869 
4870 
4871     def getfields(self):
4872         return self.__fields
4873 
4874 
4875     def _update(self, args, kwargs):
4876         super(new_writefileresponse,self)._update(args,kwargs)
4877         keys=kwargs.keys()
4878         for key in keys:
4879             if key in self.__fields:
4880                 setattr(self, key, kwargs[key])
4881                 del kwargs[key]
4882         # Were any unrecognized kwargs passed in?
4883         if __debug__:
4884             self._complainaboutunusedargs(new_writefileresponse,kwargs)
4885         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4886         # Make all P fields that haven't already been constructed
4887 
4888 
4889     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4890         'Writes this packet to the supplied buffer'
4891         self._bufferstartoffset=buf.getcurrentoffset()
4892         self.__field_header.writetobuffer(buf)
4893         self.__field_handle.writetobuffer(buf)
4894         self.__field_position.writetobuffer(buf)
4895         self.__field_bytes.writetobuffer(buf)
4896         self.__field_error.writetobuffer(buf)
4897         self._bufferendoffset=buf.getcurrentoffset()
4898         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4899 
4900 
4901     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4902         'Reads this packet from the supplied buffer'
4903         self._bufferstartoffset=buf.getcurrentoffset()
4904         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4905         self.__field_header=new_responseheader()
4906         self.__field_header.readfrombuffer(buf)
4907         self.__field_handle=UINT(**{'sizeinbytes': 4})
4908         self.__field_handle.readfrombuffer(buf)
4909         self.__field_position=UINT(**{'sizeinbytes': 4})
4910         self.__field_position.readfrombuffer(buf)
4911         self.__field_bytes=UINT(**{'sizeinbytes': 4})
4912         self.__field_bytes.readfrombuffer(buf)
4913         self.__field_error=UINT(**{'sizeinbytes': 4})
4914         self.__field_error.readfrombuffer(buf)
4915         self._bufferendoffset=buf.getcurrentoffset()
4916 
4917 
4918     def __getfield_header(self):
4919         return self.__field_header.getvalue()
4920 
4921     def __setfield_header(self, value):
4922         if isinstance(value,new_responseheader):
4923             self.__field_header=value
4924         else:
4925             self.__field_header=new_responseheader(value,)
4926 
4927     def __delfield_header(self): del self.__field_header
4928 
4929     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4930 
4931     def __getfield_handle(self):
4932         return self.__field_handle.getvalue()
4933 
4934     def __setfield_handle(self, value):
4935         if isinstance(value,UINT):
4936             self.__field_handle=value
4937         else:
4938             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
4939 
4940     def __delfield_handle(self): del self.__field_handle
4941 
4942     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
4943 
4944     def __getfield_position(self):
4945         return self.__field_position.getvalue()
4946 
4947     def __setfield_position(self, value):
4948         if isinstance(value,UINT):
4949             self.__field_position=value
4950         else:
4951             self.__field_position=UINT(value,**{'sizeinbytes': 4})
4952 
4953     def __delfield_position(self): del self.__field_position
4954 
4955     position=property(__getfield_position, __setfield_position, __delfield_position, None)
4956 
4957     def __getfield_bytes(self):
4958         return self.__field_bytes.getvalue()
4959 
4960     def __setfield_bytes(self, value):
4961         if isinstance(value,UINT):
4962             self.__field_bytes=value
4963         else:
4964             self.__field_bytes=UINT(value,**{'sizeinbytes': 4})
4965 
4966     def __delfield_bytes(self): del self.__field_bytes
4967 
4968     bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
4969 
4970     def __getfield_error(self):
4971         return self.__field_error.getvalue()
4972 
4973     def __setfield_error(self, value):
4974         if isinstance(value,UINT):
4975             self.__field_error=value
4976         else:
4977             self.__field_error=UINT(value,**{'sizeinbytes': 4})
4978 
4979     def __delfield_error(self): del self.__field_error
4980 
4981     error=property(__getfield_error, __setfield_error, __delfield_error, None)
4982 
4983     def iscontainer(self):
4984         return True
4985 
4986     def containerelements(self):
4987         yield ('header', self.__field_header, None)
4988         yield ('handle', self.__field_handle, None)
4989         yield ('position', self.__field_position, None)
4990         yield ('bytes', self.__field_bytes, None)
4991         yield ('error', self.__field_error, None)
4992 
4993 
4994 
4995 
4996 class new_rmfilerequest(BaseProtogenClass):
4997     """Remove file, full path should be provided, 
4998     but the root character / is not required at the start of the name.
4999     """
5000     __fields=['header', 'filename', 'dunno']
5001 
5002     def __init__(self, *args, **kwargs):
5003         dict={}
5004         # What was supplied to this function
5005         dict.update(kwargs)
5006         # Parent constructor
5007         super(new_rmfilerequest,self).__init__(**dict)
5008         if self.__class__ is new_rmfilerequest:
5009             self._update(args,dict)
5010 
5011 
5012     def getfields(self):
5013         return self.__fields
5014 
5015 
5016     def _update(self, args, kwargs):
5017         super(new_rmfilerequest,self)._update(args,kwargs)
5018         keys=kwargs.keys()
5019         for key in keys:
5020             if key in self.__fields:
5021                 setattr(self, key, kwargs[key])
5022                 del kwargs[key]
5023         # Were any unrecognized kwargs passed in?
5024         if __debug__:
5025             self._complainaboutunusedargs(new_rmfilerequest,kwargs)
5026         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5027         # Make all P fields that haven't already been constructed
5028 
5029 
5030     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5031         'Writes this packet to the supplied buffer'
5032         self._bufferstartoffset=buf.getcurrentoffset()
5033         try: self.__field_header
5034         except:
5035             self.__field_header=new_requestheader(**{'command': 0x08})
5036         self.__field_header.writetobuffer(buf)
5037         self.__field_filename.writetobuffer(buf)
5038         try: self.__field_dunno
5039         except:
5040             self.__field_dunno=UINT(**{'sizeinbytes': 1, 'constant':1})
5041         self.__field_dunno.writetobuffer(buf)
5042         self._bufferendoffset=buf.getcurrentoffset()
5043         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5044 
5045 
5046     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5047         'Reads this packet from the supplied buffer'
5048         self._bufferstartoffset=buf.getcurrentoffset()
5049         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5050         self.__field_header=new_requestheader(**{'command': 0x08})
5051         self.__field_header.readfrombuffer(buf)
5052         self.__field_filename=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
5053         self.__field_filename.readfrombuffer(buf)
5054         self.__field_dunno=UINT(**{'sizeinbytes': 1, 'constant':1})
5055         self.__field_dunno.readfrombuffer(buf)
5056         self._bufferendoffset=buf.getcurrentoffset()
5057 
5058 
5059     def __getfield_header(self):
5060         try: self.__field_header
5061         except:
5062             self.__field_header=new_requestheader(**{'command': 0x08})
5063         return self.__field_header.getvalue()
5064 
5065     def __setfield_header(self, value):
5066         if isinstance(value,new_requestheader):
5067             self.__field_header=value
5068         else:
5069             self.__field_header=new_requestheader(value,**{'command': 0x08})
5070 
5071     def __delfield_header(self): del self.__field_header
5072 
5073     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5074 
5075     def __getfield_filename(self):
5076         return self.__field_filename.getvalue()
5077 
5078     def __setfield_filename(self, value):
5079         if isinstance(value,USTRING):
5080             self.__field_filename=value
5081         else:
5082             self.__field_filename=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
5083 
5084     def __delfield_filename(self): del self.__field_filename
5085 
5086     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
5087 
5088     def __getfield_dunno(self):
5089         try: self.__field_dunno
5090         except:
5091             self.__field_dunno=UINT(**{'sizeinbytes': 1, 'constant':1})
5092         return self.__field_dunno.getvalue()
5093 
5094     def __setfield_dunno(self, value):
5095         if isinstance(value,UINT):
5096             self.__field_dunno=value
5097         else:
5098             self.__field_dunno=UINT(value,**{'sizeinbytes': 1, 'constant':1})
5099 
5100     def __delfield_dunno(self): del self.__field_dunno
5101 
5102     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
5103 
5104     def iscontainer(self):
5105         return True
5106 
5107     def containerelements(self):
5108         yield ('header', self.__field_header, None)
5109         yield ('filename', self.__field_filename, None)
5110         yield ('dunno', self.__field_dunno, None)
5111 
5112 
5113 
5114 
5115 class new_mkdirrequest(BaseProtogenClass):
5116     """Make a new directory, full path of the new directory should be
5117     provided, but the root character / is not required at the start of the name
5118     """
5119     __fields=['header', 'mode', 'dirname']
5120 
5121     def __init__(self, *args, **kwargs):
5122         dict={}
5123         # What was supplied to this function
5124         dict.update(kwargs)
5125         # Parent constructor
5126         super(new_mkdirrequest,self).__init__(**dict)
5127         if self.__class__ is new_mkdirrequest:
5128             self._update(args,dict)
5129 
5130 
5131     def getfields(self):
5132         return self.__fields
5133 
5134 
5135     def _update(self, args, kwargs):
5136         super(new_mkdirrequest,self)._update(args,kwargs)
5137         keys=kwargs.keys()
5138         for key in keys:
5139             if key in self.__fields:
5140                 setattr(self, key, kwargs[key])
5141                 del kwargs[key]
5142         # Were any unrecognized kwargs passed in?
5143         if __debug__:
5144             self._complainaboutunusedargs(new_mkdirrequest,kwargs)
5145         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5146         # Make all P fields that haven't already been constructed
5147 
5148 
5149     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5150         'Writes this packet to the supplied buffer'
5151         self._bufferstartoffset=buf.getcurrentoffset()
5152         try: self.__field_header
5153         except:
5154             self.__field_header=new_requestheader(**{'command': 0x09})
5155         self.__field_header.writetobuffer(buf)
5156         try: self.__field_mode
5157         except:
5158             self.__field_mode=UINT(**{'sizeinbytes': 2, 'constant': 0x01ff})
5159         self.__field_mode.writetobuffer(buf)
5160         self.__field_dirname.writetobuffer(buf)
5161         self._bufferendoffset=buf.getcurrentoffset()
5162         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5163 
5164 
5165     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5166         'Reads this packet from the supplied buffer'
5167         self._bufferstartoffset=buf.getcurrentoffset()
5168         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5169         self.__field_header=new_requestheader(**{'command': 0x09})
5170         self.__field_header.readfrombuffer(buf)
5171         self.__field_mode=UINT(**{'sizeinbytes': 2, 'constant': 0x01ff})
5172         self.__field_mode.readfrombuffer(buf)
5173         self.__field_dirname=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
5174         self.__field_dirname.readfrombuffer(buf)
5175         self._bufferendoffset=buf.getcurrentoffset()
5176 
5177 
5178     def __getfield_header(self):
5179         try: self.__field_header
5180         except:
5181             self.__field_header=new_requestheader(**{'command': 0x09})
5182         return self.__field_header.getvalue()
5183 
5184     def __setfield_header(self, value):
5185         if isinstance(value,new_requestheader):
5186             self.__field_header=value
5187         else:
5188             self.__field_header=new_requestheader(value,**{'command': 0x09})
5189 
5190     def __delfield_header(self): del self.__field_header
5191 
5192     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5193 
5194     def __getfield_mode(self):
5195         try: self.__field_mode
5196         except:
5197             self.__field_mode=UINT(**{'sizeinbytes': 2, 'constant': 0x01ff})
5198         return self.__field_mode.getvalue()
5199 
5200     def __setfield_mode(self, value):
5201         if isinstance(value,UINT):
5202             self.__field_mode=value
5203         else:
5204             self.__field_mode=UINT(value,**{'sizeinbytes': 2, 'constant': 0x01ff})
5205 
5206     def __delfield_mode(self): del self.__field_mode
5207 
5208     mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None)
5209 
5210     def __getfield_dirname(self):
5211         return self.__field_dirname.getvalue()
5212 
5213     def __setfield_dirname(self, value):
5214         if isinstance(value,USTRING):
5215             self.__field_dirname=value
5216         else:
5217             self.__field_dirname=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
5218 
5219     def __delfield_dirname(self): del self.__field_dirname
5220 
5221     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
5222 
5223     def iscontainer(self):
5224         return True
5225 
5226     def containerelements(self):
5227         yield ('header', self.__field_header, None)
5228         yield ('mode', self.__field_mode, None)
5229         yield ('dirname', self.__field_dirname, None)
5230 
5231 
5232 
5233 
5234 class new_rmdirrequest(BaseProtogenClass):
5235     """Remove directory, full path should be provided, but the
5236     root character / is not required at the start of the name.
5237     """
5238     __fields=['header', 'dirname']
5239 
5240     def __init__(self, *args, **kwargs):
5241         dict={}
5242         # What was supplied to this function
5243         dict.update(kwargs)
5244         # Parent constructor
5245         super(new_rmdirrequest,self).__init__(**dict)
5246         if self.__class__ is new_rmdirrequest:
5247             self._update(args,dict)
5248 
5249 
5250     def getfields(self):
5251         return self.__fields
5252 
5253 
5254     def _update(self, args, kwargs):
5255         super(new_rmdirrequest,self)._update(args,kwargs)
5256         keys=kwargs.keys()
5257         for key in keys:
5258             if key in self.__fields:
5259                 setattr(self, key, kwargs[key])
5260                 del kwargs[key]
5261         # Were any unrecognized kwargs passed in?
5262         if __debug__:
5263             self._complainaboutunusedargs(new_rmdirrequest,kwargs)
5264         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5265         # Make all P fields that haven't already been constructed
5266 
5267 
5268     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5269         'Writes this packet to the supplied buffer'
5270         self._bufferstartoffset=buf.getcurrentoffset()
5271         try: self.__field_header
5272         except:
5273             self.__field_header=new_requestheader(**{'command': 0x0a})
5274         self.__field_header.writetobuffer(buf)
5275         self.__field_dirname.writetobuffer(buf)
5276         self._bufferendoffset=buf.getcurrentoffset()
5277         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5278 
5279 
5280     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5281         'Reads this packet from the supplied buffer'
5282         self._bufferstartoffset=buf.getcurrentoffset()
5283         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5284         self.__field_header=new_requestheader(**{'command': 0x0a})
5285         self.__field_header.readfrombuffer(buf)
5286         self.__field_dirname=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
5287         self.__field_dirname.readfrombuffer(buf)
5288         self._bufferendoffset=buf.getcurrentoffset()
5289 
5290 
5291     def __getfield_header(self):
5292         try: self.__field_header
5293         except:
5294             self.__field_header=new_requestheader(**{'command': 0x0a})
5295         return self.__field_header.getvalue()
5296 
5297     def __setfield_header(self, value):
5298         if isinstance(value,new_requestheader):
5299             self.__field_header=value
5300         else:
5301             self.__field_header=new_requestheader(value,**{'command': 0x0a})
5302 
5303     def __delfield_header(self): del self.__field_header
5304 
5305     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5306 
5307     def __getfield_dirname(self):
5308         return self.__field_dirname.getvalue()
5309 
5310     def __setfield_dirname(self, value):
5311         if isinstance(value,USTRING):
5312             self.__field_dirname=value
5313         else:
5314             self.__field_dirname=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
5315 
5316     def __delfield_dirname(self): del self.__field_dirname
5317 
5318     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
5319 
5320     def iscontainer(self):
5321         return True
5322 
5323     def containerelements(self):
5324         yield ('header', self.__field_header, None)
5325         yield ('dirname', self.__field_dirname, None)
5326 
5327 
5328 
5329 
5330 class new_opendirectoryrequest(BaseProtogenClass):
5331     __fields=['header', 'dirname']
5332 
5333     def __init__(self, *args, **kwargs):
5334         dict={}
5335         # What was supplied to this function
5336         dict.update(kwargs)
5337         # Parent constructor
5338         super(new_opendirectoryrequest,self).__init__(**dict)
5339         if self.__class__ is new_opendirectoryrequest:
5340             self._update(args,dict)
5341 
5342 
5343     def getfields(self):
5344         return self.__fields
5345 
5346 
5347     def _update(self, args, kwargs):
5348         super(new_opendirectoryrequest,self)._update(args,kwargs)
5349         keys=kwargs.keys()
5350         for key in keys:
5351             if key in self.__fields:
5352                 setattr(self, key, kwargs[key])
5353                 del kwargs[key]
5354         # Were any unrecognized kwargs passed in?
5355         if __debug__:
5356             self._complainaboutunusedargs(new_opendirectoryrequest,kwargs)
5357         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5358         # Make all P fields that haven't already been constructed
5359 
5360 
5361     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5362         'Writes this packet to the supplied buffer'
5363         self._bufferstartoffset=buf.getcurrentoffset()
5364         try: self.__field_header
5365         except:
5366             self.__field_header=new_requestheader(**{'command': 0x0b})
5367         self.__field_header.writetobuffer(buf)
5368         self.__field_dirname.writetobuffer(buf)
5369         self._bufferendoffset=buf.getcurrentoffset()
5370         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5371 
5372 
5373     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5374         'Reads this packet from the supplied buffer'
5375         self._bufferstartoffset=buf.getcurrentoffset()
5376         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5377         self.__field_header=new_requestheader(**{'command': 0x0b})
5378         self.__field_header.readfrombuffer(buf)
5379         self.__field_dirname=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
5380         self.__field_dirname.readfrombuffer(buf)
5381         self._bufferendoffset=buf.getcurrentoffset()
5382 
5383 
5384     def __getfield_header(self):
5385         try: self.__field_header
5386         except:
5387             self.__field_header=new_requestheader(**{'command': 0x0b})
5388         return self.__field_header.getvalue()
5389 
5390     def __setfield_header(self, value):
5391         if isinstance(value,new_requestheader):
5392             self.__field_header=value
5393         else:
5394             self.__field_header=new_requestheader(value,**{'command': 0x0b})
5395 
5396     def __delfield_header(self): del self.__field_header
5397 
5398     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5399 
5400     def __getfield_dirname(self):
5401         return self.__field_dirname.getvalue()
5402 
5403     def __setfield_dirname(self, value):
5404         if isinstance(value,USTRING):
5405             self.__field_dirname=value
5406         else:
5407             self.__field_dirname=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
5408 
5409     def __delfield_dirname(self): del self.__field_dirname
5410 
5411     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
5412 
5413     def iscontainer(self):
5414         return True
5415 
5416     def containerelements(self):
5417         yield ('header', self.__field_header, None)
5418         yield ('dirname', self.__field_dirname, None)
5419 
5420 
5421 
5422 
5423 class new_opendirectoryresponse(BaseProtogenClass):
5424     __fields=['header', 'handle', 'error']
5425 
5426     def __init__(self, *args, **kwargs):
5427         dict={}
5428         # What was supplied to this function
5429         dict.update(kwargs)
5430         # Parent constructor
5431         super(new_opendirectoryresponse,self).__init__(**dict)
5432         if self.__class__ is new_opendirectoryresponse:
5433             self._update(args,dict)
5434 
5435 
5436     def getfields(self):
5437         return self.__fields
5438 
5439 
5440     def _update(self, args, kwargs):
5441         super(new_opendirectoryresponse,self)._update(args,kwargs)
5442         keys=kwargs.keys()
5443         for key in keys:
5444             if key in self.__fields:
5445                 setattr(self, key, kwargs[key])
5446                 del kwargs[key]
5447         # Were any unrecognized kwargs passed in?
5448         if __debug__:
5449             self._complainaboutunusedargs(new_opendirectoryresponse,kwargs)
5450         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5451         # Make all P fields that haven't already been constructed
5452 
5453 
5454     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5455         'Writes this packet to the supplied buffer'
5456         self._bufferstartoffset=buf.getcurrentoffset()
5457         self.__field_header.writetobuffer(buf)
5458         self.__field_handle.writetobuffer(buf)
5459         self.__field_error.writetobuffer(buf)
5460         self._bufferendoffset=buf.getcurrentoffset()
5461         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5462 
5463 
5464     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5465         'Reads this packet from the supplied buffer'
5466         self._bufferstartoffset=buf.getcurrentoffset()
5467         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5468         self.__field_header=new_responseheader()
5469         self.__field_header.readfrombuffer(buf)
5470         self.__field_handle=UINT(**{'sizeinbytes': 4})
5471         self.__field_handle.readfrombuffer(buf)
5472         self.__field_error=UINT(**{'sizeinbytes': 4})
5473         self.__field_error.readfrombuffer(buf)
5474         self._bufferendoffset=buf.getcurrentoffset()
5475 
5476 
5477     def __getfield_header(self):
5478         return self.__field_header.getvalue()
5479 
5480     def __setfield_header(self, value):
5481         if isinstance(value,new_responseheader):
5482             self.__field_header=value
5483         else:
5484             self.__field_header=new_responseheader(value,)
5485 
5486     def __delfield_header(self): del self.__field_header
5487 
5488     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5489 
5490     def __getfield_handle(self):
5491         return self.__field_handle.getvalue()
5492 
5493     def __setfield_handle(self, value):
5494         if isinstance(value,UINT):
5495             self.__field_handle=value
5496         else:
5497             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
5498 
5499     def __delfield_handle(self): del self.__field_handle
5500 
5501     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
5502 
5503     def __getfield_error(self):
5504         return self.__field_error.getvalue()
5505 
5506     def __setfield_error(self, value):
5507         if isinstance(value,UINT):
5508             self.__field_error=value
5509         else:
5510             self.__field_error=UINT(value,**{'sizeinbytes': 4})
5511 
5512     def __delfield_error(self): del self.__field_error
5513 
5514     error=property(__getfield_error, __setfield_error, __delfield_error, None)
5515 
5516     def iscontainer(self):
5517         return True
5518 
5519     def containerelements(self):
5520         yield ('header', self.__field_header, None)
5521         yield ('handle', self.__field_handle, None)
5522         yield ('error', self.__field_error, None)
5523 
5524 
5525 
5526 
5527 class new_listentryrequest(BaseProtogenClass):
5528     __fields=['header', 'handle', 'entrynumber']
5529 
5530     def __init__(self, *args, **kwargs):
5531         dict={}
5532         # What was supplied to this function
5533         dict.update(kwargs)
5534         # Parent constructor
5535         super(new_listentryrequest,self).__init__(**dict)
5536         if self.__class__ is new_listentryrequest:
5537             self._update(args,dict)
5538 
5539 
5540     def getfields(self):
5541         return self.__fields
5542 
5543 
5544     def _update(self, args, kwargs):
5545         super(new_listentryrequest,self)._update(args,kwargs)
5546         keys=kwargs.keys()
5547         for key in keys:
5548             if key in self.__fields:
5549                 setattr(self, key, kwargs[key])
5550                 del kwargs[key]
5551         # Were any unrecognized kwargs passed in?
5552         if __debug__:
5553             self._complainaboutunusedargs(new_listentryrequest,kwargs)
5554         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5555         # Make all P fields that haven't already been constructed
5556 
5557 
5558     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5559         'Writes this packet to the supplied buffer'
5560         self._bufferstartoffset=buf.getcurrentoffset()
5561         try: self.__field_header
5562         except:
5563             self.__field_header=new_requestheader(**{'command': 0x0c})
5564         self.__field_header.writetobuffer(buf)
5565         self.__field_handle.writetobuffer(buf)
5566         self.__field_entrynumber.writetobuffer(buf)
5567         self._bufferendoffset=buf.getcurrentoffset()
5568         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5569 
5570 
5571     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5572         'Reads this packet from the supplied buffer'
5573         self._bufferstartoffset=buf.getcurrentoffset()
5574         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5575         self.__field_header=new_requestheader(**{'command': 0x0c})
5576         self.__field_header.readfrombuffer(buf)
5577         self.__field_handle=UINT(**{'sizeinbytes': 4})
5578         self.__field_handle.readfrombuffer(buf)
5579         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
5580         self.__field_entrynumber.readfrombuffer(buf)
5581         self._bufferendoffset=buf.getcurrentoffset()
5582 
5583 
5584     def __getfield_header(self):
5585         try: self.__field_header
5586         except:
5587             self.__field_header=new_requestheader(**{'command': 0x0c})
5588         return self.__field_header.getvalue()
5589 
5590     def __setfield_header(self, value):
5591         if isinstance(value,new_requestheader):
5592             self.__field_header=value
5593         else:
5594             self.__field_header=new_requestheader(value,**{'command': 0x0c})
5595 
5596     def __delfield_header(self): del self.__field_header
5597 
5598     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5599 
5600     def __getfield_handle(self):
5601         return self.__field_handle.getvalue()
5602 
5603     def __setfield_handle(self, value):
5604         if isinstance(value,UINT):
5605             self.__field_handle=value
5606         else:
5607             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
5608 
5609     def __delfield_handle(self): del self.__field_handle
5610 
5611     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
5612 
5613     def __getfield_entrynumber(self):
5614         return self.__field_entrynumber.getvalue()
5615 
5616     def __setfield_entrynumber(self, value):
5617         if isinstance(value,UINT):
5618             self.__field_entrynumber=value
5619         else:
5620             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
5621 
5622     def __delfield_entrynumber(self): del self.__field_entrynumber
5623 
5624     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
5625 
5626     def iscontainer(self):
5627         return True
5628 
5629     def containerelements(self):
5630         yield ('header', self.__field_header, None)
5631         yield ('handle', self.__field_handle, None)
5632         yield ('entrynumber', self.__field_entrynumber, None)
5633 
5634 
5635 
5636 
5637 class new_listentryresponse(BaseProtogenClass):
5638     __fields=['header', 'handle', 'entrynumber', 'pad1', 'type', 'mode', 'size', 'pad2', 'date', 'entryname']
5639 
5640     def __init__(self, *args, **kwargs):
5641         dict={}
5642         # What was supplied to this function
5643         dict.update(kwargs)
5644         # Parent constructor
5645         super(new_listentryresponse,self).__init__(**dict)
5646         if self.__class__ is new_listentryresponse:
5647             self._update(args,dict)
5648 
5649 
5650     def getfields(self):
5651         return self.__fields
5652 
5653 
5654     def _update(self, args, kwargs):
5655         super(new_listentryresponse,self)._update(args,kwargs)
5656         keys=kwargs.keys()
5657         for key in keys:
5658             if key in self.__fields:
5659                 setattr(self, key, kwargs[key])
5660                 del kwargs[key]
5661         # Were any unrecognized kwargs passed in?
5662         if __debug__:
5663             self._complainaboutunusedargs(new_listentryresponse,kwargs)
5664         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5665         # Make all P fields that haven't already been constructed
5666 
5667 
5668     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5669         'Writes this packet to the supplied buffer'
5670         self._bufferstartoffset=buf.getcurrentoffset()
5671         self.__field_header.writetobuffer(buf)
5672         self.__field_handle.writetobuffer(buf)
5673         self.__field_entrynumber.writetobuffer(buf)
5674         self.__field_pad1.writetobuffer(buf)
5675         self.__field_type.writetobuffer(buf)
5676         self.__field_mode.writetobuffer(buf)
5677         self.__field_size.writetobuffer(buf)
5678         self.__field_pad2.writetobuffer(buf)
5679         self.__field_date.writetobuffer(buf)
5680         self.__field_entryname.writetobuffer(buf)
5681         self._bufferendoffset=buf.getcurrentoffset()
5682         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5683 
5684 
5685     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5686         'Reads this packet from the supplied buffer'
5687         self._bufferstartoffset=buf.getcurrentoffset()
5688         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5689         self.__field_header=new_responseheader()
5690         self.__field_header.readfrombuffer(buf)
5691         self.__field_handle=UINT(**{'sizeinbytes': 4})
5692         self.__field_handle.readfrombuffer(buf)
5693         self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
5694         self.__field_entrynumber.readfrombuffer(buf)
5695         self.__field_pad1=UINT(**{'sizeinbytes': 4})
5696         self.__field_pad1.readfrombuffer(buf)
5697         self.__field_type=UINT(**{'sizeinbytes': 4})
5698         self.__field_type.readfrombuffer(buf)
5699         self.__field_mode=UINT(**{'sizeinbytes': 4})
5700         self.__field_mode.readfrombuffer(buf)
5701         self.__field_size=UINT(**{'sizeinbytes': 4})
5702         self.__field_size.readfrombuffer(buf)
5703         self.__field_pad2=UINT(**{'sizeinbytes': 8})
5704         self.__field_pad2.readfrombuffer(buf)
5705         self.__field_date=UINT(**{'sizeinbytes': 4})
5706         self.__field_date.readfrombuffer(buf)
5707         self.__field_entryname=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
5708         self.__field_entryname.readfrombuffer(buf)
5709         self._bufferendoffset=buf.getcurrentoffset()
5710 
5711 
5712     def __getfield_header(self):
5713         return self.__field_header.getvalue()
5714 
5715     def __setfield_header(self, value):
5716         if isinstance(value,new_responseheader):
5717             self.__field_header=value
5718         else:
5719             self.__field_header=new_responseheader(value,)
5720 
5721     def __delfield_header(self): del self.__field_header
5722 
5723     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5724 
5725     def __getfield_handle(self):
5726         return self.__field_handle.getvalue()
5727 
5728     def __setfield_handle(self, value):
5729         if isinstance(value,UINT):
5730             self.__field_handle=value
5731         else:
5732             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
5733 
5734     def __delfield_handle(self): del self.__field_handle
5735 
5736     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
5737 
5738     def __getfield_entrynumber(self):
5739         return self.__field_entrynumber.getvalue()
5740 
5741     def __setfield_entrynumber(self, value):
5742         if isinstance(value,UINT):
5743             self.__field_entrynumber=value
5744         else:
5745             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
5746 
5747     def __delfield_entrynumber(self): del self.__field_entrynumber
5748 
5749     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
5750 
5751     def __getfield_pad1(self):
5752         return self.__field_pad1.getvalue()
5753 
5754     def __setfield_pad1(self, value):
5755         if isinstance(value,UINT):
5756             self.__field_pad1=value
5757         else:
5758             self.__field_pad1=UINT(value,**{'sizeinbytes': 4})
5759 
5760     def __delfield_pad1(self): del self.__field_pad1
5761 
5762     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
5763 
5764     def __getfield_type(self):
5765         return self.__field_type.getvalue()
5766 
5767     def __setfield_type(self, value):
5768         if isinstance(value,UINT):
5769             self.__field_type=value
5770         else:
5771             self.__field_type=UINT(value,**{'sizeinbytes': 4})
5772 
5773     def __delfield_type(self): del self.__field_type
5774 
5775     type=property(__getfield_type, __setfield_type, __delfield_type, None)
5776 
5777     def __getfield_mode(self):
5778         return self.__field_mode.getvalue()
5779 
5780     def __setfield_mode(self, value):
5781         if isinstance(value,UINT):
5782             self.__field_mode=value
5783         else:
5784             self.__field_mode=UINT(value,**{'sizeinbytes': 4})
5785 
5786     def __delfield_mode(self): del self.__field_mode
5787 
5788     mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None)
5789 
5790     def __getfield_size(self):
5791         return self.__field_size.getvalue()
5792 
5793     def __setfield_size(self, value):
5794         if isinstance(value,UINT):
5795             self.__field_size=value
5796         else:
5797             self.__field_size=UINT(value,**{'sizeinbytes': 4})
5798 
5799     def __delfield_size(self): del self.__field_size
5800 
5801     size=property(__getfield_size, __setfield_size, __delfield_size, None)
5802 
5803     def __getfield_pad2(self):
5804         return self.__field_pad2.getvalue()
5805 
5806     def __setfield_pad2(self, value):
5807         if isinstance(value,UINT):
5808             self.__field_pad2=value
5809         else:
5810             self.__field_pad2=UINT(value,**{'sizeinbytes': 8})
5811 
5812     def __delfield_pad2(self): del self.__field_pad2
5813 
5814     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
5815 
5816     def __getfield_date(self):
5817         return self.__field_date.getvalue()
5818 
5819     def __setfield_date(self, value):
5820         if isinstance(value,UINT):
5821             self.__field_date=value
5822         else:
5823             self.__field_date=UINT(value,**{'sizeinbytes': 4})
5824 
5825     def __delfield_date(self): del self.__field_date
5826 
5827     date=property(__getfield_date, __setfield_date, __delfield_date, None)
5828 
5829     def __getfield_entryname(self):
5830         return self.__field_entryname.getvalue()
5831 
5832     def __setfield_entryname(self, value):
5833         if isinstance(value,USTRING):
5834             self.__field_entryname=value
5835         else:
5836             self.__field_entryname=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
5837 
5838     def __delfield_entryname(self): del self.__field_entryname
5839 
5840     entryname=property(__getfield_entryname, __setfield_entryname, __delfield_entryname, None)
5841 
5842     def iscontainer(self):
5843         return True
5844 
5845     def containerelements(self):
5846         yield ('header', self.__field_header, None)
5847         yield ('handle', self.__field_handle, None)
5848         yield ('entrynumber', self.__field_entrynumber, None)
5849         yield ('pad1', self.__field_pad1, None)
5850         yield ('type', self.__field_type, None)
5851         yield ('mode', self.__field_mode, None)
5852         yield ('size', self.__field_size, None)
5853         yield ('pad2', self.__field_pad2, None)
5854         yield ('date', self.__field_date, None)
5855         yield ('entryname', self.__field_entryname, None)
5856 
5857 
5858 
5859 
5860 class new_closedirectoryrequest(BaseProtogenClass):
5861     __fields=['header', 'handle']
5862 
5863     def __init__(self, *args, **kwargs):
5864         dict={}
5865         # What was supplied to this function
5866         dict.update(kwargs)
5867         # Parent constructor
5868         super(new_closedirectoryrequest,self).__init__(**dict)
5869         if self.__class__ is new_closedirectoryrequest:
5870             self._update(args,dict)
5871 
5872 
5873     def getfields(self):
5874         return self.__fields
5875 
5876 
5877     def _update(self, args, kwargs):
5878         super(new_closedirectoryrequest,self)._update(args,kwargs)
5879         keys=kwargs.keys()
5880         for key in keys:
5881             if key in self.__fields:
5882                 setattr(self, key, kwargs[key])
5883                 del kwargs[key]
5884         # Were any unrecognized kwargs passed in?
5885         if __debug__:
5886             self._complainaboutunusedargs(new_closedirectoryrequest,kwargs)
5887         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5888         # Make all P fields that haven't already been constructed
5889 
5890 
5891     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5892         'Writes this packet to the supplied buffer'
5893         self._bufferstartoffset=buf.getcurrentoffset()
5894         try: self.__field_header
5895         except:
5896             self.__field_header=new_requestheader(**{'command': 0x0d})
5897         self.__field_header.writetobuffer(buf)
5898         self.__field_handle.writetobuffer(buf)
5899         self._bufferendoffset=buf.getcurrentoffset()
5900         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5901 
5902 
5903     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5904         'Reads this packet from the supplied buffer'
5905         self._bufferstartoffset=buf.getcurrentoffset()
5906         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5907         self.__field_header=new_requestheader(**{'command': 0x0d})
5908         self.__field_header.readfrombuffer(buf)
5909         self.__field_handle=UINT(**{'sizeinbytes': 4})
5910         self.__field_handle.readfrombuffer(buf)
5911         self._bufferendoffset=buf.getcurrentoffset()
5912 
5913 
5914     def __getfield_header(self):
5915         try: self.__field_header
5916         except:
5917             self.__field_header=new_requestheader(**{'command': 0x0d})
5918         return self.__field_header.getvalue()
5919 
5920     def __setfield_header(self, value):
5921         if isinstance(value,new_requestheader):
5922             self.__field_header=value
5923         else:
5924             self.__field_header=new_requestheader(value,**{'command': 0x0d})
5925 
5926     def __delfield_header(self): del self.__field_header
5927 
5928     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5929 
5930     def __getfield_handle(self):
5931         return self.__field_handle.getvalue()
5932 
5933     def __setfield_handle(self, value):
5934         if isinstance(value,UINT):
5935             self.__field_handle=value
5936         else:
5937             self.__field_handle=UINT(value,**{'sizeinbytes': 4})
5938 
5939     def __delfield_handle(self): del self.__field_handle
5940 
5941     handle=property(__getfield_handle, __setfield_handle, __delfield_handle, None)
5942 
5943     def iscontainer(self):
5944         return True
5945 
5946     def containerelements(self):
5947         yield ('header', self.__field_header, None)
5948         yield ('handle', self.__field_handle, None)
5949 
5950 
5951 
5952 
5953 class new_closedirectoryresponse(BaseProtogenClass):
5954     __fields=['header', 'error']
5955 
5956     def __init__(self, *args, **kwargs):
5957         dict={}
5958         # What was supplied to this function
5959         dict.update(kwargs)
5960         # Parent constructor
5961         super(new_closedirectoryresponse,self).__init__(**dict)
5962         if self.__class__ is new_closedirectoryresponse:
5963             self._update(args,dict)
5964 
5965 
5966     def getfields(self):
5967         return self.__fields
5968 
5969 
5970     def _update(self, args, kwargs):
5971         super(new_closedirectoryresponse,self)._update(args,kwargs)
5972         keys=kwargs.keys()
5973         for key in keys:
5974             if key in self.__fields:
5975                 setattr(self, key, kwargs[key])
5976                 del kwargs[key]
5977         # Were any unrecognized kwargs passed in?
5978         if __debug__:
5979             self._complainaboutunusedargs(new_closedirectoryresponse,kwargs)
5980         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5981         # Make all P fields that haven't already been constructed
5982 
5983 
5984     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5985         'Writes this packet to the supplied buffer'
5986         self._bufferstartoffset=buf.getcurrentoffset()
5987         self.__field_header.writetobuffer(buf)
5988         self.__field_error.writetobuffer(buf)
5989         self._bufferendoffset=buf.getcurrentoffset()
5990         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5991 
5992 
5993     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5994         'Reads this packet from the supplied buffer'
5995         self._bufferstartoffset=buf.getcurrentoffset()
5996         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5997         self.__field_header=new_responseheader()
5998         self.__field_header.readfrombuffer(buf)
5999         self.__field_error=UINT(**{'sizeinbytes': 4})
6000         self.__field_error.readfrombuffer(buf)
6001         self._bufferendoffset=buf.getcurrentoffset()
6002 
6003 
6004     def __getfield_header(self):
6005         return self.__field_header.getvalue()
6006 
6007     def __setfield_header(self, value):
6008         if isinstance(value,new_responseheader):
6009             self.__field_header=value
6010         else:
6011             self.__field_header=new_responseheader(value,)
6012 
6013     def __delfield_header(self): del self.__field_header
6014 
6015     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6016 
6017     def __getfield_error(self):
6018         return self.__field_error.getvalue()
6019 
6020     def __setfield_error(self, value):
6021         if isinstance(value,UINT):
6022             self.__field_error=value
6023         else:
6024             self.__field_error=UINT(value,**{'sizeinbytes': 4})
6025 
6026     def __delfield_error(self): del self.__field_error
6027 
6028     error=property(__getfield_error, __setfield_error, __delfield_error, None)
6029 
6030     def iscontainer(self):
6031         return True
6032 
6033     def containerelements(self):
6034         yield ('header', self.__field_header, None)
6035         yield ('error', self.__field_error, None)
6036 
6037 
6038 
6039 
6040 class new_statfilerequest(BaseProtogenClass):
6041     "Get the status of the file"
6042     __fields=['header', 'filename']
6043 
6044     def __init__(self, *args, **kwargs):
6045         dict={}
6046         # What was supplied to this function
6047         dict.update(kwargs)
6048         # Parent constructor
6049         super(new_statfilerequest,self).__init__(**dict)
6050         if self.__class__ is new_statfilerequest:
6051             self._update(args,dict)
6052 
6053 
6054     def getfields(self):
6055         return self.__fields
6056 
6057 
6058     def _update(self, args, kwargs):
6059         super(new_statfilerequest,self)._update(args,kwargs)
6060         keys=kwargs.keys()
6061         for key in keys:
6062             if key in self.__fields:
6063                 setattr(self, key, kwargs[key])
6064                 del kwargs[key]
6065         # Were any unrecognized kwargs passed in?
6066         if __debug__:
6067             self._complainaboutunusedargs(new_statfilerequest,kwargs)
6068         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6069         # Make all P fields that haven't already been constructed
6070 
6071 
6072     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6073         'Writes this packet to the supplied buffer'
6074         self._bufferstartoffset=buf.getcurrentoffset()
6075         try: self.__field_header
6076         except:
6077             self.__field_header=new_requestheader(**{ 'command': 0x0f })
6078         self.__field_header.writetobuffer(buf)
6079         self.__field_filename.writetobuffer(buf)
6080         self._bufferendoffset=buf.getcurrentoffset()
6081         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6082 
6083 
6084     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6085         'Reads this packet from the supplied buffer'
6086         self._bufferstartoffset=buf.getcurrentoffset()
6087         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6088         self.__field_header=new_requestheader(**{ 'command': 0x0f })
6089         self.__field_header.readfrombuffer(buf)
6090         self.__field_filename=USTRING(**{'terminator': 0,               'encoding': PHONE_ENCODING })
6091         self.__field_filename.readfrombuffer(buf)
6092         self._bufferendoffset=buf.getcurrentoffset()
6093 
6094 
6095     def __getfield_header(self):
6096         try: self.__field_header
6097         except:
6098             self.__field_header=new_requestheader(**{ 'command': 0x0f })
6099         return self.__field_header.getvalue()
6100 
6101     def __setfield_header(self, value):
6102         if isinstance(value,new_requestheader):
6103             self.__field_header=value
6104         else:
6105             self.__field_header=new_requestheader(value,**{ 'command': 0x0f })
6106 
6107     def __delfield_header(self): del self.__field_header
6108 
6109     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6110 
6111     def __getfield_filename(self):
6112         return self.__field_filename.getvalue()
6113 
6114     def __setfield_filename(self, value):
6115         if isinstance(value,USTRING):
6116             self.__field_filename=value
6117         else:
6118             self.__field_filename=USTRING(value,**{'terminator': 0,               'encoding': PHONE_ENCODING })
6119 
6120     def __delfield_filename(self): del self.__field_filename
6121 
6122     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
6123 
6124     def iscontainer(self):
6125         return True
6126 
6127     def containerelements(self):
6128         yield ('header', self.__field_header, None)
6129         yield ('filename', self.__field_filename, None)
6130 
6131 
6132 
6133 
6134 class new_statfileresponse(BaseProtogenClass):
6135     __fields=['header', 'error', 'dunno', 'size', 'type', 'accessed_date', 'modified_date', 'created_date']
6136 
6137     def __init__(self, *args, **kwargs):
6138         dict={}
6139         # What was supplied to this function
6140         dict.update(kwargs)
6141         # Parent constructor
6142         super(new_statfileresponse,self).__init__(**dict)
6143         if self.__class__ is new_statfileresponse:
6144             self._update(args,dict)
6145 
6146 
6147     def getfields(self):
6148         return self.__fields
6149 
6150 
6151     def _update(self, args, kwargs):
6152         super(new_statfileresponse,self)._update(args,kwargs)
6153         keys=kwargs.keys()
6154         for key in keys:
6155             if key in self.__fields:
6156                 setattr(self, key, kwargs[key])
6157                 del kwargs[key]
6158         # Were any unrecognized kwargs passed in?
6159         if __debug__:
6160             self._complainaboutunusedargs(new_statfileresponse,kwargs)
6161         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6162         # Make all P fields that haven't already been constructed
6163 
6164 
6165     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6166         'Writes this packet to the supplied buffer'
6167         self._bufferstartoffset=buf.getcurrentoffset()
6168         self.__field_header.writetobuffer(buf)
6169         self.__field_error.writetobuffer(buf)
6170         self.__field_dunno.writetobuffer(buf)
6171         self.__field_size.writetobuffer(buf)
6172         self.__field_type.writetobuffer(buf)
6173         self.__field_accessed_date.writetobuffer(buf)
6174         self.__field_modified_date.writetobuffer(buf)
6175         self.__field_created_date.writetobuffer(buf)
6176         self._bufferendoffset=buf.getcurrentoffset()
6177         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6178 
6179 
6180     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6181         'Reads this packet from the supplied buffer'
6182         self._bufferstartoffset=buf.getcurrentoffset()
6183         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6184         self.__field_header=new_responseheader()
6185         self.__field_header.readfrombuffer(buf)
6186         self.__field_error=UINT(**{'sizeinbytes': 4})
6187         self.__field_error.readfrombuffer(buf)
6188         self.__field_dunno=UNKNOWN(**{'sizeinbytes': 4})
6189         self.__field_dunno.readfrombuffer(buf)
6190         self.__field_size=UINT(**{'sizeinbytes': 4})
6191         self.__field_size.readfrombuffer(buf)
6192         self.__field_type=UINT(**{'sizeinbytes': 4})
6193         self.__field_type.readfrombuffer(buf)
6194         self.__field_accessed_date=UINT(**{'sizeinbytes': 4})
6195         self.__field_accessed_date.readfrombuffer(buf)
6196         self.__field_modified_date=UINT(**{'sizeinbytes': 4})
6197         self.__field_modified_date.readfrombuffer(buf)
6198         self.__field_created_date=UINT(**{'sizeinbytes': 4})
6199         self.__field_created_date.readfrombuffer(buf)
6200         self._bufferendoffset=buf.getcurrentoffset()
6201 
6202 
6203     def __getfield_header(self):
6204         return self.__field_header.getvalue()
6205 
6206     def __setfield_header(self, value):
6207         if isinstance(value,new_responseheader):
6208             self.__field_header=value
6209         else:
6210             self.__field_header=new_responseheader(value,)
6211 
6212     def __delfield_header(self): del self.__field_header
6213 
6214     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6215 
6216     def __getfield_error(self):
6217         return self.__field_error.getvalue()
6218 
6219     def __setfield_error(self, value):
6220         if isinstance(value,UINT):
6221             self.__field_error=value
6222         else:
6223             self.__field_error=UINT(value,**{'sizeinbytes': 4})
6224 
6225     def __delfield_error(self): del self.__field_error
6226 
6227     error=property(__getfield_error, __setfield_error, __delfield_error, None)
6228 
6229     def __getfield_dunno(self):
6230         return self.__field_dunno.getvalue()
6231 
6232     def __setfield_dunno(self, value):
6233         if isinstance(value,UNKNOWN):
6234             self.__field_dunno=value
6235         else:
6236             self.__field_dunno=UNKNOWN(value,**{'sizeinbytes': 4})
6237 
6238     def __delfield_dunno(self): del self.__field_dunno
6239 
6240     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
6241 
6242     def __getfield_size(self):
6243         return self.__field_size.getvalue()
6244 
6245     def __setfield_size(self, value):
6246         if isinstance(value,UINT):
6247             self.__field_size=value
6248         else:
6249             self.__field_size=UINT(value,**{'sizeinbytes': 4})
6250 
6251     def __delfield_size(self): del self.__field_size
6252 
6253     size=property(__getfield_size, __setfield_size, __delfield_size, None)
6254 
6255     def __getfield_type(self):
6256         return self.__field_type.getvalue()
6257 
6258     def __setfield_type(self, value):
6259         if isinstance(value,UINT):
6260             self.__field_type=value
6261         else:
6262             self.__field_type=UINT(value,**{'sizeinbytes': 4})
6263 
6264     def __delfield_type(self): del self.__field_type
6265 
6266     type=property(__getfield_type, __setfield_type, __delfield_type, None)
6267 
6268     def __getfield_accessed_date(self):
6269         return self.__field_accessed_date.getvalue()
6270 
6271     def __setfield_accessed_date(self, value):
6272         if isinstance(value,UINT):
6273             self.__field_accessed_date=value
6274         else:
6275             self.__field_accessed_date=UINT(value,**{'sizeinbytes': 4})
6276 
6277     def __delfield_accessed_date(self): del self.__field_accessed_date
6278 
6279     accessed_date=property(__getfield_accessed_date, __setfield_accessed_date, __delfield_accessed_date, None)
6280 
6281     def __getfield_modified_date(self):
6282         return self.__field_modified_date.getvalue()
6283 
6284     def __setfield_modified_date(self, value):
6285         if isinstance(value,UINT):
6286             self.__field_modified_date=value
6287         else:
6288             self.__field_modified_date=UINT(value,**{'sizeinbytes': 4})
6289 
6290     def __delfield_modified_date(self): del self.__field_modified_date
6291 
6292     modified_date=property(__getfield_modified_date, __setfield_modified_date, __delfield_modified_date, None)
6293 
6294     def __getfield_created_date(self):
6295         return self.__field_created_date.getvalue()
6296 
6297     def __setfield_created_date(self, value):
6298         if isinstance(value,UINT):
6299             self.__field_created_date=value
6300         else:
6301             self.__field_created_date=UINT(value,**{'sizeinbytes': 4})
6302 
6303     def __delfield_created_date(self): del self.__field_created_date
6304 
6305     created_date=property(__getfield_created_date, __setfield_created_date, __delfield_created_date, None)
6306 
6307     def iscontainer(self):
6308         return True
6309 
6310     def containerelements(self):
6311         yield ('header', self.__field_header, None)
6312         yield ('error', self.__field_error, None)
6313         yield ('dunno', self.__field_dunno, None)
6314         yield ('size', self.__field_size, None)
6315         yield ('type', self.__field_type, None)
6316         yield ('accessed_date', self.__field_accessed_date, None)
6317         yield ('modified_date', self.__field_modified_date, None)
6318         yield ('created_date', self.__field_created_date, None)
6319 
6320 
6321 
6322 
6323 class new_chmodrequest(BaseProtogenClass):
6324     __fields=['header', 'mode', 'filename']
6325 
6326     def __init__(self, *args, **kwargs):
6327         dict={}
6328         # What was supplied to this function
6329         dict.update(kwargs)
6330         # Parent constructor
6331         super(new_chmodrequest,self).__init__(**dict)
6332         if self.__class__ is new_chmodrequest:
6333             self._update(args,dict)
6334 
6335 
6336     def getfields(self):
6337         return self.__fields
6338 
6339 
6340     def _update(self, args, kwargs):
6341         super(new_chmodrequest,self)._update(args,kwargs)
6342         keys=kwargs.keys()
6343         for key in keys:
6344             if key in self.__fields:
6345                 setattr(self, key, kwargs[key])
6346                 del kwargs[key]
6347         # Were any unrecognized kwargs passed in?
6348         if __debug__:
6349             self._complainaboutunusedargs(new_chmodrequest,kwargs)
6350         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6351         # Make all P fields that haven't already been constructed
6352 
6353 
6354     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6355         'Writes this packet to the supplied buffer'
6356         self._bufferstartoffset=buf.getcurrentoffset()
6357         try: self.__field_header
6358         except:
6359             self.__field_header=new_requestheader(**{'command': 0x12})
6360         self.__field_header.writetobuffer(buf)
6361         try: self.__field_mode
6362         except:
6363             self.__field_mode=UINT(**{'sizeinbytes': 2})
6364         self.__field_mode.writetobuffer(buf)
6365         try: self.__field_filename
6366         except:
6367             self.__field_filename=USTRING(**{'terminator': 0, 'encoding': PHONE_ENCODING })
6368         self.__field_filename.writetobuffer(buf)
6369         self._bufferendoffset=buf.getcurrentoffset()
6370         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6371 
6372 
6373     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6374         'Reads this packet from the supplied buffer'
6375         self._bufferstartoffset=buf.getcurrentoffset()
6376         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6377         self.__field_header=new_requestheader(**{'command': 0x12})
6378         self.__field_header.readfrombuffer(buf)
6379         self.__field_mode=UINT(**{'sizeinbytes': 2})
6380         self.__field_mode.readfrombuffer(buf)
6381         self.__field_filename=USTRING(**{'terminator': 0, 'encoding': PHONE_ENCODING })
6382         self.__field_filename.readfrombuffer(buf)
6383         self._bufferendoffset=buf.getcurrentoffset()
6384 
6385 
6386     def __getfield_header(self):
6387         try: self.__field_header
6388         except:
6389             self.__field_header=new_requestheader(**{'command': 0x12})
6390         return self.__field_header.getvalue()
6391 
6392     def __setfield_header(self, value):
6393         if isinstance(value,new_requestheader):
6394             self.__field_header=value
6395         else:
6396             self.__field_header=new_requestheader(value,**{'command': 0x12})
6397 
6398     def __delfield_header(self): del self.__field_header
6399 
6400     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6401 
6402     def __getfield_mode(self):
6403         try: self.__field_mode
6404         except:
6405             self.__field_mode=UINT(**{'sizeinbytes': 2})
6406         return self.__field_mode.getvalue()
6407 
6408     def __setfield_mode(self, value):
6409         if isinstance(value,UINT):
6410             self.__field_mode=value
6411         else:
6412             self.__field_mode=UINT(value,**{'sizeinbytes': 2})
6413 
6414     def __delfield_mode(self): del self.__field_mode
6415 
6416     mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None)
6417 
6418     def __getfield_filename(self):
6419         try: self.__field_filename
6420         except:
6421             self.__field_filename=USTRING(**{'terminator': 0, 'encoding': PHONE_ENCODING })
6422         return self.__field_filename.getvalue()
6423 
6424     def __setfield_filename(self, value):
6425         if isinstance(value,USTRING):
6426             self.__field_filename=value
6427         else:
6428             self.__field_filename=USTRING(value,**{'terminator': 0, 'encoding': PHONE_ENCODING })
6429 
6430     def __delfield_filename(self): del self.__field_filename
6431 
6432     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
6433 
6434     def iscontainer(self):
6435         return True
6436 
6437     def containerelements(self):
6438         yield ('header', self.__field_header, None)
6439         yield ('mode', self.__field_mode, None)
6440         yield ('filename', self.__field_filename, None)
6441 
6442 
6443 
6444 
6445 class new_chmodresponse(BaseProtogenClass):
6446     __fields=['header', 'error']
6447 
6448     def __init__(self, *args, **kwargs):
6449         dict={}
6450         # What was supplied to this function
6451         dict.update(kwargs)
6452         # Parent constructor
6453         super(new_chmodresponse,self).__init__(**dict)
6454         if self.__class__ is new_chmodresponse:
6455             self._update(args,dict)
6456 
6457 
6458     def getfields(self):
6459         return self.__fields
6460 
6461 
6462     def _update(self, args, kwargs):
6463         super(new_chmodresponse,self)._update(args,kwargs)
6464         keys=kwargs.keys()
6465         for key in keys:
6466             if key in self.__fields:
6467                 setattr(self, key, kwargs[key])
6468                 del kwargs[key]
6469         # Were any unrecognized kwargs passed in?
6470         if __debug__:
6471             self._complainaboutunusedargs(new_chmodresponse,kwargs)
6472         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6473         # Make all P fields that haven't already been constructed
6474 
6475 
6476     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6477         'Writes this packet to the supplied buffer'
6478         self._bufferstartoffset=buf.getcurrentoffset()
6479         self.__field_header.writetobuffer(buf)
6480         self.__field_error.writetobuffer(buf)
6481         self._bufferendoffset=buf.getcurrentoffset()
6482         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6483 
6484 
6485     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6486         'Reads this packet from the supplied buffer'
6487         self._bufferstartoffset=buf.getcurrentoffset()
6488         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6489         self.__field_header=new_responseheader()
6490         self.__field_header.readfrombuffer(buf)
6491         self.__field_error=UINT(**{'sizeinbytes': 4})
6492         self.__field_error.readfrombuffer(buf)
6493         self._bufferendoffset=buf.getcurrentoffset()
6494 
6495 
6496     def __getfield_header(self):
6497         return self.__field_header.getvalue()
6498 
6499     def __setfield_header(self, value):
6500         if isinstance(value,new_responseheader):
6501             self.__field_header=value
6502         else:
6503             self.__field_header=new_responseheader(value,)
6504 
6505     def __delfield_header(self): del self.__field_header
6506 
6507     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6508 
6509     def __getfield_error(self):
6510         return self.__field_error.getvalue()
6511 
6512     def __setfield_error(self, value):
6513         if isinstance(value,UINT):
6514             self.__field_error=value
6515         else:
6516             self.__field_error=UINT(value,**{'sizeinbytes': 4})
6517 
6518     def __delfield_error(self): del self.__field_error
6519 
6520     error=property(__getfield_error, __setfield_error, __delfield_error, None)
6521 
6522     def iscontainer(self):
6523         return True
6524 
6525     def containerelements(self):
6526         yield ('header', self.__field_header, None)
6527         yield ('error', self.__field_error, None)
6528 
6529 
6530 
6531 
6532 class new_reconfigfilesystemrequest(BaseProtogenClass):
6533     """Called after mkdir/rmdir and writing files,
6534     possibly a filesystem status request with space used/free etc.
6535     """
6536     __fields=['header', 'dirname']
6537 
6538     def __init__(self, *args, **kwargs):
6539         dict={}
6540         # What was supplied to this function
6541         dict.update(kwargs)
6542         # Parent constructor
6543         super(new_reconfigfilesystemrequest,self).__init__(**dict)
6544         if self.__class__ is new_reconfigfilesystemrequest:
6545             self._update(args,dict)
6546 
6547 
6548     def getfields(self):
6549         return self.__fields
6550 
6551 
6552     def _update(self, args, kwargs):
6553         super(new_reconfigfilesystemrequest,self)._update(args,kwargs)
6554         keys=kwargs.keys()
6555         for key in keys:
6556             if key in self.__fields:
6557                 setattr(self, key, kwargs[key])
6558                 del kwargs[key]
6559         # Were any unrecognized kwargs passed in?
6560         if __debug__:
6561             self._complainaboutunusedargs(new_reconfigfilesystemrequest,kwargs)
6562         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6563         # Make all P fields that haven't already been constructed
6564 
6565 
6566     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6567         'Writes this packet to the supplied buffer'
6568         self._bufferstartoffset=buf.getcurrentoffset()
6569         try: self.__field_header
6570         except:
6571             self.__field_header=new_requestheader(**{'command': 0x13})
6572         self.__field_header.writetobuffer(buf)
6573         try: self.__field_dirname
6574         except:
6575             self.__field_dirname=UINT(**{'sizeinbytes': 2, 'constant': 0x002f})
6576         self.__field_dirname.writetobuffer(buf)
6577         self._bufferendoffset=buf.getcurrentoffset()
6578         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6579 
6580 
6581     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6582         'Reads this packet from the supplied buffer'
6583         self._bufferstartoffset=buf.getcurrentoffset()
6584         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6585         self.__field_header=new_requestheader(**{'command': 0x13})
6586         self.__field_header.readfrombuffer(buf)
6587         self.__field_dirname=UINT(**{'sizeinbytes': 2, 'constant': 0x002f})
6588         self.__field_dirname.readfrombuffer(buf)
6589         self._bufferendoffset=buf.getcurrentoffset()
6590 
6591 
6592     def __getfield_header(self):
6593         try: self.__field_header
6594         except:
6595             self.__field_header=new_requestheader(**{'command': 0x13})
6596         return self.__field_header.getvalue()
6597 
6598     def __setfield_header(self, value):
6599         if isinstance(value,new_requestheader):
6600             self.__field_header=value
6601         else:
6602             self.__field_header=new_requestheader(value,**{'command': 0x13})
6603 
6604     def __delfield_header(self): del self.__field_header
6605 
6606     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6607 
6608     def __getfield_dirname(self):
6609         try: self.__field_dirname
6610         except:
6611             self.__field_dirname=UINT(**{'sizeinbytes': 2, 'constant': 0x002f})
6612         return self.__field_dirname.getvalue()
6613 
6614     def __setfield_dirname(self, value):
6615         if isinstance(value,UINT):
6616             self.__field_dirname=value
6617         else:
6618             self.__field_dirname=UINT(value,**{'sizeinbytes': 2, 'constant': 0x002f})
6619 
6620     def __delfield_dirname(self): del self.__field_dirname
6621 
6622     dirname=property(__getfield_dirname, __setfield_dirname, __delfield_dirname, None)
6623 
6624     def iscontainer(self):
6625         return True
6626 
6627     def containerelements(self):
6628         yield ('header', self.__field_header, None)
6629         yield ('dirname', self.__field_dirname, None)
6630 
6631 
6632 
6633 
6634 class new_reconfigfilesystemresponse(BaseProtogenClass):
6635     __fields=['header', 'unknown']
6636 
6637     def __init__(self, *args, **kwargs):
6638         dict={}
6639         # What was supplied to this function
6640         dict.update(kwargs)
6641         # Parent constructor
6642         super(new_reconfigfilesystemresponse,self).__init__(**dict)
6643         if self.__class__ is new_reconfigfilesystemresponse:
6644             self._update(args,dict)
6645 
6646 
6647     def getfields(self):
6648         return self.__fields
6649 
6650 
6651     def _update(self, args, kwargs):
6652         super(new_reconfigfilesystemresponse,self)._update(args,kwargs)
6653         keys=kwargs.keys()
6654         for key in keys:
6655             if key in self.__fields:
6656                 setattr(self, key, kwargs[key])
6657                 del kwargs[key]
6658         # Were any unrecognized kwargs passed in?
6659         if __debug__:
6660             self._complainaboutunusedargs(new_reconfigfilesystemresponse,kwargs)
6661         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6662         # Make all P fields that haven't already been constructed
6663 
6664 
6665     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6666         'Writes this packet to the supplied buffer'
6667         self._bufferstartoffset=buf.getcurrentoffset()
6668         self.__field_header.writetobuffer(buf)
6669         try: self.__field_unknown
6670         except:
6671             self.__field_unknown=UNKNOWN(**{'sizeinbytes': 44})
6672         self.__field_unknown.writetobuffer(buf)
6673         self._bufferendoffset=buf.getcurrentoffset()
6674         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6675 
6676 
6677     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6678         'Reads this packet from the supplied buffer'
6679         self._bufferstartoffset=buf.getcurrentoffset()
6680         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6681         self.__field_header=new_responseheader()
6682         self.__field_header.readfrombuffer(buf)
6683         self.__field_unknown=UNKNOWN(**{'sizeinbytes': 44})
6684         self.__field_unknown.readfrombuffer(buf)
6685         self._bufferendoffset=buf.getcurrentoffset()
6686 
6687 
6688     def __getfield_header(self):
6689         return self.__field_header.getvalue()
6690 
6691     def __setfield_header(self, value):
6692         if isinstance(value,new_responseheader):
6693             self.__field_header=value
6694         else:
6695             self.__field_header=new_responseheader(value,)
6696 
6697     def __delfield_header(self): del self.__field_header
6698 
6699     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6700 
6701     def __getfield_unknown(self):
6702         try: self.__field_unknown
6703         except:
6704             self.__field_unknown=UNKNOWN(**{'sizeinbytes': 44})
6705         return self.__field_unknown.getvalue()
6706 
6707     def __setfield_unknown(self, value):
6708         if isinstance(value,UNKNOWN):
6709             self.__field_unknown=value
6710         else:
6711             self.__field_unknown=UNKNOWN(value,**{'sizeinbytes': 44})
6712 
6713     def __delfield_unknown(self): del self.__field_unknown
6714 
6715     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
6716 
6717     def iscontainer(self):
6718         return True
6719 
6720     def containerelements(self):
6721         yield ('header', self.__field_header, None)
6722         yield ('unknown', self.__field_unknown, None)
6723 
6724 
6725 
6726 
6727 # Several responses are nothing
6728 mkdirresponse=responseheader
6729 rmdirresponse=responseheader
6730 rmfileresponse=responseheader
6731 writefileresponse=responseheader
6732 writefileblockresponse=responseheader
6733 setfileattrresponse=responseheader
6734 new_mkdirresponse=new_responseheader
6735 new_rmdirresponse=new_responseheader
6736 new_rmfileresponse=new_responseheader
6737