compressor.hxx

#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/crypto/algorithm.hxx>
#include <StormByte/crypto/exception.hxx>
#include <StormByte/expected.hxx>
 
#include <string>
 
namespace StormByte::Crypto {
    class STORMBYTE_CRYPTO_PUBLIC Compressor final {
        public:
            explicit Compressor(const Algorithm::Compress& algorithm) noexcept;
 
            Compressor(const Compressor& compressor)                    = default;
 
            Compressor(Compressor&& compressor) noexcept                = default;
 
            ~Compressor() noexcept                                      = default;
 
            Compressor& operator=(const Compressor& compressor)         = default;
 
            Compressor& operator=(Compressor&& compressor) noexcept     = default;
 
            [[nodiscard]]
            Expected<std::string, Exception>                            Compress(const std::string& input) const noexcept;
 
            [[nodiscard]]
            Expected<Buffer::Simple, Exception>                         Compress(const Buffer::Simple& buffer) const noexcept;
 
            [[nodiscard]]
            Buffer::Consumer                                            Compress(const Buffer::Consumer consumer) const noexcept;
 
            [[nodiscard]]
            Expected<std::string, Exception>                            Decompress(const std::string& input) const noexcept;
 
            [[nodiscard]]
            Expected<Buffer::Simple, Exception>                         Decompress(const Buffer::Simple& buffer) const noexcept;
 
            [[nodiscard]]
            Buffer::Consumer                                            Decompress(const Buffer::Consumer consumer) const noexcept;
 
        private:
            const Algorithm::Compress m_algorithm; 
    };
}