be_io_gzip.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_IO_GZIP__
#define __BE_IO_GZIP__
 
#include <string>
#include <zlib.h>
 
#include <be_error_exception.h>
#include <be_io_compressor.h>
#include <be_io_properties.h>
#include <be_memory_autoarray.h>
 
namespace BiometricEvaluation 
{
        namespace IO
        {
                class GZip : public Compressor
                {
                public:
                        /*
                         * zlib compressor property keys.
                         */
                        static const std::string COMPRESSION_LEVEL;
                        static const std::string COMPRESSION_STRATEGY;
                        static const std::string COMPRESSION_METHOD;
                        static const std::string INPUT_DATA_TYPE;
                        static const std::string WINDOW_BITS;
                        static const std::string MEMORY_LEVEL;
                        static const std::string CHUNK_SIZE;
 
                        GZip();
 
                        Memory::uint8Array
                        compress(
                            const uint8_t *const uncompressedData,
                            uint64_t uncompressedDataSize)
                            const;
 
                        Memory::uint8Array
                        compress(
                            const Memory::uint8Array &uncompressedData)
                            const;
 
                        void
                        compress(
                            const uint8_t *const uncompressedData,
                            uint64_t uncompressedDataSize,
                            const std::string &outputFile) const;
 
                        void
                        compress(
                            const Memory::uint8Array &uncompressedData,
                            const std::string &outputFile) const;
    
                        Memory::uint8Array
                        compress(
                            const std::string &inputFile)
                            const;
 
                        void
                        compress(
                            const std::string &inputFile,
                            const std::string &outputFile) const;
 
                        Memory::uint8Array
                        decompress(
                            const uint8_t *const compressedData,
                            uint64_t compressedDataSize)
                            const;
 
                        Memory::uint8Array
                        decompress(
                            const Memory::uint8Array &compressedData)
                            const;
 
                        Memory::uint8Array
                        decompress(
                            const std::string &input)
                            const;
 
                        void
                        decompress(
                            const std::string &inputFile,
                            const std::string &outputFile) const;
 
                        void
                        decompress(
                            const uint8_t *const compressedData,
                            const uint64_t compressedDataSize,
                            const std::string &outputFile) const;
 
                        void
                        decompress(
                            const Memory::uint8Array &compressedData,
                            const std::string &outputFile) const;
 
                        ~GZip();
                
                        GZip(
                            const GZip &other) = delete;
 
                        GZip&
                        operator=(
                            const GZip& other) = delete;
 
                private:
                        z_stream
                        initCompressionStream()
                            const;
                            
                        int32_t
                        compressChunk(
                            uint8_t flush,
                            uint64_t chunkSize,
                            uint64_t &totalCompressedBytes,
                            Memory::uint8Array &compressedBuf,
                            bool compressedBufIsChunk,
                            z_stream &strm) const;
 
                        z_stream
                        initDecompressionStream()
                            const;
                            
                        int32_t
                        decompressChunk(
                            uint64_t chunkSize,
                            uint64_t &totalUncompressedBytes,
                            Memory::uint8Array &uncompressedBuf,
                            bool uncompressedBufIsChunk,
                            z_stream &strm) const;
 
                        static const uint8_t GZIP_WBITS_MAGIC = 16;
                };
        }
}
 
#endif /* __BE_IO_GZIP__ */