be_io_compressor.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_COMPRESSOR__
#define __BE_IO_COMPRESSOR__
 
#include <map>
#include <memory>
#include <string>
 
#include <be_error_exception.h>
#include <be_framework_enumeration.h>
#include <be_io_properties.h>
#include <be_memory_autoarray.h>
 
namespace BiometricEvaluation 
{
        namespace IO
        {
                class Compressor
                {
                public:
                        enum class Kind {
                                GZIP
                        };
                                        
                        Compressor();
                        
                        virtual Memory::uint8Array
                        compress(
                            const uint8_t *const uncompressedData,
                            uint64_t uncompressedDataSize)
                            const = 0;
                        
                        virtual Memory::uint8Array
                        compress(
                            const Memory::uint8Array &uncompressedData)
                            const = 0;
 
                        virtual void
                        compress(
                            const uint8_t *const uncompressedData,
                            uint64_t uncompressedDataSize,
                            const std::string &outputFile) const = 0;
 
                        virtual void
                        compress(
                            const Memory::uint8Array &uncompressedData,
                            const std::string &outputFile) const = 0;
 
                        virtual Memory::uint8Array
                        compress(
                            const std::string &inputFile)
                            const = 0;
 
                        virtual void
                        compress(
                            const std::string &inputFile,
                            const std::string &outputFile) const = 0;
 
                        virtual Memory::uint8Array
                        decompress(
                            const uint8_t *const compressedData,
                            uint64_t compressedDataSize)
                            const = 0;
 
                        virtual Memory::uint8Array
                        decompress(
                            const Memory::uint8Array &compressedData)
                            const = 0;
 
                        virtual Memory::uint8Array
                        decompress(
                            const std::string &inputFile)
                            const = 0;
 
                        virtual void
                        decompress(
                            const Memory::uint8Array &compressedData,
                            const std::string &outputFile) const = 0;
 
                        virtual void
                        decompress(
                            const uint8_t *const compressedData,
                            const uint64_t compressedDataSize,
                            const std::string &outputFile) const = 0;
 
                        virtual void
                        decompress(
                            const std::string &inputFile,
                            const std::string &outputFile) const = 0;
 
                        void
                        setOption(
                            const std::string &optionName,
                            const std::string &optionValue);
 
                        void
                        setOption(
                            const std::string &optionName,
                            int64_t optionValue);
 
                        std::string
                        getOption(
                            const std::string &optionName) const;
 
                        int64_t
                        getOptionAsInteger(
                            const std::string &optionName) const;
 
                        void
                        removeOption(
                            const std::string &optionName);
 
                        virtual ~Compressor();
                        
                        static std::shared_ptr<Compressor>
                        createCompressor(
                            Compressor::Kind compressorKind = Kind::GZIP);
 
                        Compressor(
                            const Compressor &other) = delete;
 
                        Compressor&
                        operator=(
                            const Compressor& other) = delete;
 
                private:
                        Properties _compressorOptions;
                };
        }
}
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::IO::Compressor::Kind,
    BE_IO_Compressor_Kind_EnumToStringMap);
 
#endif /* __BE_IO_COMPRESSOR__ */