generic.hxx

#pragma once
 
#include <StormByte/crypto/keypair/generic.hxx>
 
namespace StormByte::Crypto::Secret {
    enum class Type {
        ECDH,                                                   
        X25519,                                                 
    };
 
    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;
 
            KeyPair::Generic::PointerType                       KeyPair() const noexcept {
                return m_keypair;
            }
 
            enum Type                                           Type() const noexcept {
                return m_type;
            }
 
            inline std::optional<std::string>                   Share(const std::string& peerPublicKey) const noexcept {
                return DoShare(peerPublicKey);
            }
 
        protected:
            enum Type m_type;                                   
            KeyPair::Generic::PointerType m_keypair;            
 
            inline                                              Generic(enum Type type, KeyPair::Generic::PointerType keypair):
            m_type(type), m_keypair(keypair) {}
 
            inline                                              Generic(enum Type type, const KeyPair::Generic& keypair):
            m_type(type), m_keypair(keypair.Clone()) {}
 
            inline                                              Generic(enum Type type, KeyPair::Generic&& keypair):
            m_type(type), m_keypair(keypair.Move()) {}
 
        private:
            virtual std::optional<std::string>                  DoShare(const std::string& peerPublicKey) const noexcept = 0;
    };
 
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                Create(enum Type type, KeyPair::Generic::PointerType keypair) noexcept;
}