file/zip/codec.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2005 by Reality Rift Studios                       *
 *   http://www.realityrift.com  -  mattias@realityrift.com                *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef neo_file_zip_codec_h
#define neo_file_zip_codec_h

#include "../../core/platform.h"

#if NEO_ENABLE_FILE_ZIP

#include "../package.h"
#include "../bufferstream.h"

namespace neo {
namespace file {
namespace zip {

class Package;

struct EndOfCD
{
    public:

    char                                                    _signature[4];
    uint16_t                                                _disc;
    uint16_t                                                _discCD;
    uint16_t                                                _numEntries;
    uint16_t                                                _numEntriesTotal;
    uint32_t                                                _sizeCD;
    uint32_t                                                _offsetCD;
    uint16_t                                                _sizeComment;
};

struct CDFileHeader
{
    public:

    char                                                    _signature[4];
    uint16_t                                                _versionMade;
    uint16_t                                                _versionExtract;
    uint16_t                                                _flags;
    uint16_t                                                _compression;
    uint16_t                                                _modTime;
    uint16_t                                                _modDate;
    uint32_t                                                _crc32;
    uint32_t                                                _sizeCompressed;
    uint32_t                                                _sizeUncompressed;
    uint16_t                                                _sizeFilename;
    uint16_t                                                _sizeExtra;
    uint16_t                                                _sizeComment;
    uint16_t                                                _disc;
    uint16_t                                                _attribInternal;
    uint32_t                                                _attribExternal;
    uint32_t                                                _offset;
};

struct LocalHeader
{
    public:

    char                                                    _signature[4];
    uint16_t                                                _versionExtract;
    uint16_t                                                _flags;
    uint16_t                                                _compression;
    uint16_t                                                _modTime;
    uint16_t                                                _modDate;
    uint32_t                                                _crc32;
    uint32_t                                                _sizeCompressed;
    uint32_t                                                _sizeUncompressed;
    uint16_t                                                _sizeFilename;
    uint16_t                                                _sizeExtra;
};

class BufferStream : public file::BufferStream
{
    public:


                                                            BufferStream( Package* p_package, CDFileHeader* p_header, const std::string& path, unsigned int mode );

    virtual                                                ~BufferStream();
    
    BufferStream*                                           clone() const;
    
    protected:
    
    Package*                                                _p_package;

    CDFileHeader*                                           _p_header;
};

class Package : public file::Package
{
    public:

                                                            Package( const std::string& path, file::IOStream* p_stream, bool writeenable );
    virtual                                                ~Package();
    

    std::string                                             parse();
    
    virtual IOStream*                                       openFile( const std::string& path, unsigned int mode );
    virtual bool                                            hasDirectory( const std::string& path );
    virtual void                                            getFiles( const std::string& path, core::Array< std::string >* p_array );
    virtual void                                            getSubdirs( const std::string& path, core::Array< std::string >* p_array );
    virtual bool                                            isFile( const std::string& path );
    virtual bool                                            removeFile( const std::string& path );
    virtual bool                                            removeDirectory( const std::string& path );
    virtual bool                                            isValid() const;


    void                                                    updateArchive( CDFileHeader* p_file, int method, const unsigned char* p_buffer, unsigned int sizeCompressed, unsigned int sizeUncompressed, unsigned int crc );


    inline IOStream*                                        getStream() { return _p_stream; }

    private:

    bool                                                    _valid;
    
    EndOfCD                                                 _eocd;

    core::HashTable< std::string, CDFileHeader* >           _files;
};

class Codec : public neo::file::PackageCodec
{

    public:

                                                            Codec();
    virtual                                                ~Codec();

    virtual file::Package*                                  allocate( const std::string& path, file::IOStream* p_stream, bool writeenable );
};


}
}
}

#endif

#endif

---