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::Hasher {
    enum class Type {
        Blake2b,                                                
        Blake2s,                                                
        SHA3_256,                                               
        SHA3_512,                                               
        SHA256,                                             
        SHA512,                                             
    };
 
    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                                         Hash(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept {
                return DoHash(input, output);
            }
 
            inline bool                                         Hash(const Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoHash(const_cast<Buffer::ReadOnly&>(input), output, ReadMode::Copy);
            }
 
            inline bool                                         Hash(Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoHash(input, output, ReadMode::Move);
            }
 
            inline Buffer::Consumer                             Hash(Buffer::Consumer consumer, ReadMode mode = ReadMode::Move) const noexcept {
                return DoHash(consumer, mode);
            }
 
            inline enum Type                                    Type() const noexcept {
                return m_type;
            }
 
        protected:
            enum Type m_type;                                   
 
            inline                                              Generic(enum Type type):
            m_type(type) {}
 
        private:
            bool                                                DoHash(Buffer::ReadOnly& input, Buffer::WriteOnly& output, ReadMode mode) const noexcept;
 
            virtual bool                                        DoHash(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept = 0;
 
            virtual Buffer::Consumer                            DoHash(Buffer::Consumer consumer, ReadMode mode) const noexcept = 0;
    };
 
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                Create(Type type) noexcept;
}