generic.hxx

#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/clonable.hxx>
#include <StormByte/crypto/typedefs.hxx>
#include <StormByte/crypto/visibility.h>
 
namespace StormByte::Crypto::Compressor {
    enum class Type {
        Bzip2,                                                  
        Zlib                                                    
    };
 
    class STORMBYTE_CRYPTO_PUBLIC Generic: public StormByte::Clonable<Generic> {
        public:
            Generic(const Generic& other)                       = default;
 
            Generic(Generic&& other) noexcept                   = default;
 
            virtual ~Generic() noexcept                         = default;
 
            Generic& operator=(const Generic& other)            = default;
 
            Generic& operator=(Generic&& other) noexcept        = default;
 
            inline bool                                         Compress(const std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept {
                return DoCompress(input, output);
            }
 
            inline bool                                         Compress(const Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoCompress(const_cast<Buffer::ReadOnly&>(input), output, ReadMode::Copy);
            }
 
            inline bool                                         Compress(Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoCompress(input, output, ReadMode::Move);
            }
 
            inline Buffer::Consumer                             Compress(Buffer::Consumer consumer, ReadMode mode = ReadMode::Move) const noexcept {
                return DoCompress(consumer, mode);
            }
 
            inline bool                                         Decompress(const std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept {
                return DoDecompress(input, output);
            }
 
            inline bool                                         Decompress(const Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoDecompress(const_cast<Buffer::ReadOnly&>(input), output, ReadMode::Copy);
            }
 
            inline bool                                         Decompress(Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoDecompress(input, output, ReadMode::Move);
            }
 
            inline Buffer::Consumer                             Decompress(Buffer::Consumer consumer, ReadMode mode = ReadMode::Move) const noexcept {
                return DoDecompress(consumer, mode);
            }
 
            unsigned short                                      Level() const noexcept {
                return m_level;
            }
 
            inline enum Type                                    Type() const noexcept {
                return m_type;
            }
 
        protected:
            enum Type m_type;                                   
            unsigned short m_level = 0;                         
 
            inline                                              Generic(enum Type type, unsigned short level = 5):
            m_type(type), m_level(level) {}
 
        private:
            virtual bool                                        DoCompress(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept = 0;
 
            bool                                                DoCompress(Buffer::ReadOnly& input, Buffer::WriteOnly& output, ReadMode mode) const noexcept;
 
            virtual Buffer::Consumer                            DoCompress(Buffer::Consumer consumer, ReadMode mode) const noexcept = 0;
 
            virtual bool                                        DoDecompress(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept = 0;
 
            bool                                                DoDecompress(Buffer::ReadOnly& input, Buffer::WriteOnly& output, ReadMode mode) const noexcept;
 
            virtual Buffer::Consumer                            DoDecompress(Buffer::Consumer consumer, ReadMode mode) const noexcept = 0;
    };
 
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                Create(Type type, unsigned short level) noexcept;
}