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