- Added check_byte

- Added final keyword everywhere. In theory this can help with optimization and LTO. I'm really not liking the use of inheritance. That's such a code smell in 2025

Author: me

src/msgpack.h

@@ -136,13 +136,6 @@ namespace msgpackcpp
         void unpack(source_base& in);
         static value unpack_static(source_base& in);
     };
-    
-//----------------------------------------------------------------------------------------------------------------
-
-    template<class Byte>
-    constexpr bool is_byte = std::is_same_v<Byte, char>     || 
-                             std::is_same_v<Byte, uint8_t>  ||
-                             std::is_same_v<Byte, int8_t>;
 
 //----------------------------------------------------------------------------------------------------------------
 
@@ -293,6 +286,16 @@ namespace msgpackcpp
     }
 #endif
 
+//----------------------------------------------------------------------------------------------------------------
+
+    template<class Byte>
+    constexpr bool is_byte = std::is_same_v<Byte, char>     || 
+                             std::is_same_v<Byte, uint8_t>  ||
+                             std::is_same_v<Byte, int8_t>;
+
+    template<class Byte>
+    using check_byte = std::enable_if_t<is_byte<Byte>, bool>;
+
 //----------------------------------------------------------------------------------------------------------------
 
     constexpr uint16_t byte_swap16(uint16_t v)
@@ -501,7 +504,7 @@ namespace msgpackcpp
         }
         else
         {
-            // negative - int64_T
+            // negative - int64_t
             constexpr uint8_t format = MSGPACK_I64;
             const     uint64_t v64   = host_to_b64(bit_cast<uint64_t>(static_cast<int64_t>(v)));
             out.write((const char*)&format, 1);

src/msgpack_sinks.h

@@ -12,7 +12,7 @@ namespace msgpackcpp
 //----------------------------------------------------------------------------------------------------------------
 
     template<class Byte, class Alloc>
-    struct sink_vector : sink_base
+    struct sink_vector final : sink_base
     {
         static_assert(is_byte<Byte>, "Byte needs to be a byte");
         std::vector<Byte,Alloc>& buf;
@@ -26,77 +26,77 @@ namespace msgpackcpp
     };
 
     template<class Byte, class Alloc>
-    struct source_vector : source_base
+    struct source_vector final : source_base
     {
         static_assert(is_byte<Byte>, "Byte needs to be a byte");
         const std::vector<Byte,Alloc>& data;
         size_t offset{0};
 
         source_vector(const std::vector<Byte,Alloc>& data_) : data{data_} {}
 
-        void read(char* buf, size_t nbytes) override
+        void read(char* buf, size_t nbytes) override final
         {
             if ((data.size() - offset) < nbytes)
                 throw std::system_error(OUT_OF_DATA);
             std::memcpy(buf, data.data() + offset, nbytes);
             offset += nbytes;
         }
 
-        uint8_t peak() override
+        uint8_t peak() override final
         {
             return static_cast<uint8_t>(data[offset]);
         }
 
-        size_t remaining() const override
+        size_t remaining() const override final
         {
             return data.size() - offset;
         }
     };
 
-    template<class Byte, class Alloc, std::enable_if_t<is_byte<Byte>, bool> = true>
+    template<class Byte, class Alloc, check_byte<Byte> = true>
     auto sink(std::vector<Byte, Alloc>& buf)
     {
         return sink_vector<Byte,Alloc>{buf};
     }
 
-    template<class Byte, class Alloc, std::enable_if_t<is_byte<Byte>, bool> = true>
+    template<class Byte, class Alloc, check_byte<Byte> = true>
     auto source(const std::vector<Byte, Alloc>& buf)
     {
         return source_vector<Byte,Alloc>{buf};
     }
 
 //----------------------------------------------------------------------------------------------------------------
 
-    struct ostream_sink : sink_base
+    struct ostream_sink final : sink_base
     {
         std::ostream& out;
 
         ostream_sink(std::ostream& out_) : out{out_}{}
-        void write(const char* data, size_t nbytes) override {out.write(data, nbytes);}
+        void write(const char* data, size_t nbytes) override final {out.write(data, nbytes);}
     };
 
-    struct istream_source : source_base
+    struct istream_source final : source_base
     {
         std::istream& in;
 
         istream_source(std::istream& in_) : in{in_}{}
 
-        void read(char* buf, size_t nbytes) override
+        void read(char* buf, size_t nbytes) override final
         {
             in.read(buf, nbytes);
             if (in.gcount() != (long)nbytes)
                 throw std::system_error(OUT_OF_DATA);
         }
 
-        uint8_t peak() override
+        uint8_t peak() override final
         {
             uint8_t b = static_cast<uint8_t>(in.peek());
             if (!in || !in.good() || in.eof())
                 throw std::system_error(OUT_OF_DATA);
             return b;
         }
 
-        size_t remaining() const override
+        size_t remaining() const override final
         {
             const auto pos = in.tellg();
             in.seekg(0, std::ios::end );