Replace Encryptor CRTP base with a concept.

Chaos/Cipher/Block/Des/DesCrypt.hpp

@@ -233,7 +233,7 @@ public:
         Inner_::RawKey Key_;
     };
 
-    class Encryptor : public Chaos::Cipher::Block::Encryptor<Encryptor>
+    class Encryptor
     {
     public:
         using Block = DesCrypt::Block;
@@ -279,6 +279,8 @@ public:
         Inner_::KeySchedule Schedule_;
     };
 
+    static_assert(Chaos::Cipher::Block::Encryptor<Encryptor>);
+
     class Decryptor : public Chaos::Cipher::Block::Decryptor<Decryptor>
     {
     public:

Chaos/Cipher/Block/Encryptor.hpp

@@ -1,44 +1,27 @@
 #ifndef CHAOS_CIPHER_BLOCK_ENCRYPTOR_HPP
 #define CHAOS_CIPHER_BLOCK_ENCRYPTOR_HPP
 
+#include <concepts>
+#include <cstdint>
+#include <type_traits>
+
 namespace Chaos::Cipher::Block
 {
 
 template<typename T>
-class Encryptor
+concept Encryptor = requires(T encryptor,
+                             typename T::Block block,
+                             uint8_t * outBegin, uint8_t * outEnd,
+                             uint8_t * inBegin, uint8_t * inEnd)
 {
-public:
-    template<typename OutputIt, typename InputIt>
-    void EncryptBlock(OutputIt outBegin, OutputIt outEnd,
-                      InputIt inBegin, InputIt inEnd) const
-    {
-        Impl().EncryptBlock(outBegin, outEnd, inBegin, inEnd);
-    }
-
-    template<typename Block>
-    auto EncryptBlock(Block block) const
-    {
-        return Impl().EncryptBlock(block);
-    }
-
-    auto GetBlockSize() const
-    {
-        return Impl().GetBlockSize();
-    }
-
-protected:
-    Encryptor() = default;
-
-private:
-    const T & Impl() const
-    {
-        return static_cast<const T &>(*this);
-    }
-
-    T & Impl()
-    {
-        return static_cast<T &>(*this);
-    }
+    typename T::Block;
+    typename T::Key;
+    requires std::constructible_from<T, typename T::Key>;
+    requires std::unsigned_integral<std::remove_cvref_t<decltype(T::BlockSize)>>;
+    requires std::unsigned_integral<std::remove_cvref_t<decltype(T::KeySize)>>;
+    encryptor.EncryptBlock(outBegin, outEnd, inBegin, inEnd);
+    { encryptor.EncryptBlock(block) } -> std::same_as<typename T::Block>;
+    { encryptor.GetBlockSize() } -> std::unsigned_integral;
 };
 
 } // namespace Chaos::Cipher::Block

ChaosTests/Cipher/Block/Des/DesCryptTests.cpp

@@ -486,8 +486,8 @@ TEST(DesCryptTests, OutIteratorUsageDecryptTest)
     }
 }
 
-template<typename Impl, typename InputIt>
-static std::vector<uint8_t> EncryptThroughBase(const Encryptor<Impl> & enc,
+template<Encryptor EncryptorImpl, typename InputIt>
+static std::vector<uint8_t> EncryptGeneric(const EncryptorImpl & enc,
                                            InputIt begin, InputIt end)
 {
     std::vector<uint8_t> result;
@@ -497,7 +497,7 @@ static std::vector<uint8_t> EncryptThroughBase(const Encryptor<Impl> & enc,
     return result;
 }
 
-TEST(DesCryptTests, EncryptThroughBaseTest)
+TEST(DesCryptTests, EncryptGenericTest)
 {
     std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
@@ -507,16 +507,16 @@ TEST(DesCryptTests, EncryptThroughBaseTest)
     DesCrypt::Key desKey(key.begin(), key.end());
     DesCrypt::Encryptor enc(desKey);
 
-    ASSERT_EQ(expected, EncryptThroughBase(enc, data.begin(), data.end()));
+    ASSERT_EQ(expected, EncryptGeneric(enc, data.begin(), data.end()));
 }
 
-template<typename Impl>
-static uint64_t EncryptUInt64BlockThroughBase(const Encryptor<Impl> & enc, uint64_t block)
+template<Encryptor EncryptorImpl>
+static uint64_t EncryptUInt64BlockGeneric(const EncryptorImpl & enc, uint64_t block)
 {
     return enc.EncryptBlock(block);
 }
 
-TEST(DesCryptTests, EncryptUInt64BlockThroughBaseTest)
+TEST(DesCryptTests, EncryptUInt64BlockGenericTest)
 {
     std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
@@ -526,7 +526,7 @@ TEST(DesCryptTests, EncryptUInt64BlockThroughBaseTest)
     DesCrypt::Key desKey(key.begin(), key.end());
     DesCrypt::Encryptor enc(desKey);
 
-    ASSERT_EQ(expected, EncryptUInt64BlockThroughBase(enc, data));
+    ASSERT_EQ(expected, EncryptUInt64BlockGeneric(enc, data));
 }
 
 template<typename Impl, typename InputIt>