Implement new KVP MoQ structure

- Add for parameters
- Consolidate uint64_t enum coding
- Move parameters to new structure

Author: RichLogan

include/quicr/detail/ctrl_message_types.h

@@ -19,6 +19,71 @@ namespace quicr::messages {
     using GroupId = uint64_t;
     using ObjectId = uint64_t;
 
+    /// MoQ Key Value Pair.
+    template<typename T>
+    concept KeyType =
+      std::same_as<T, std::uint64_t> || (std::is_enum_v<T> && std::same_as<std::underlying_type_t<T>, std::uint64_t>);
+    template<KeyType T>
+    struct KeyValuePair
+    {
+        T type;
+        Bytes value;
+    };
+    template<KeyType T>
+    Bytes& operator<<(Bytes& buffer, const KeyValuePair<T>& param)
+    {
+        const auto type = static_cast<std::uint64_t>(param.type);
+        buffer << UintVar(type);
+        if (type % 2 == 0) {
+            // Even, single varint of value.
+            assert(param.value.size() <= 8);
+            std::uint64_t val = 0;
+            std::memcpy(&val, param.value.data(), std::min(param.value.size(), sizeof(std::uint64_t)));
+            buffer << UintVar(val);
+        } else {
+            // Odd, encode bytes.
+            buffer << UintVar(param.value.size());
+            buffer.insert(buffer.end(), param.value.begin(), param.value.end());
+        }
+        return buffer;
+    }
+    template<KeyType T>
+    BytesSpan operator>>(BytesSpan buffer, KeyValuePair<T>& param)
+    {
+        std::uint64_t type;
+        buffer = buffer >> type;
+        param.type = static_cast<T>(type);
+        if (type % 2 == 0) {
+            // Even, single varint of value.
+            std::uint64_t val;
+            buffer = buffer >> val;
+            param.value.resize(sizeof(std::uint64_t));
+            std::memcpy(param.value.data(), &val, sizeof(std::uint64_t));
+        } else {
+            // Odd, decode bytes.
+            uint64_t size = 0;
+            buffer = buffer >> size;
+            param.value.assign(buffer.begin(), std::next(buffer.begin(), size));
+        }
+        return buffer;
+    }
+
+    // Serialization for all uint64_t/enum(uint64_t to varint).
+    template<KeyType T>
+    Bytes& operator<<(Bytes& buffer, const T value)
+    {
+        buffer << UintVar(static_cast<std::uint64_t>(value));
+        return buffer;
+    }
+    template<KeyType T>
+    BytesSpan operator>>(BytesSpan buffer, T& value)
+    {
+        std::uint64_t uvalue;
+        buffer = buffer >> uvalue;
+        value = static_cast<T>(uvalue);
+        return buffer;
+    }
+
     enum struct ParameterType : uint64_t
     {
         kPath = 0x1,
@@ -27,14 +92,7 @@ namespace quicr::messages {
         kInvalid = 0xFF,       // used internally.
     };
 
-    struct Parameter
-    {
-        ParameterType type{ 0 };
-        Bytes value;
-    };
-
-    Bytes& operator<<(Bytes& buffer, ParameterType value);
-    BytesSpan operator>>(BytesSpan buffer, ParameterType& value);
+    using Parameter = KeyValuePair<ParameterType>;
 
     enum struct GroupOrder : uint8_t
     {
@@ -55,9 +113,6 @@ namespace quicr::messages {
         kAbsoluteRange
     };
 
-    Bytes& operator<<(Bytes& buffer, FilterType value);
-    BytesSpan operator>>(BytesSpan buffer, FilterType& value);
-
     enum class TrackStatusCode : uint64_t
     {
         kInProgress = 0x00,
@@ -67,9 +122,6 @@ namespace quicr::messages {
         kUnknown
     };
 
-    Bytes& operator<<(Bytes& buffer, TrackStatusCode value);
-    BytesSpan operator>>(BytesSpan buffer, TrackStatusCode& value);
-
     enum class SubscribeDoneStatusCode : uint64_t
     {
         kInternalError = 0x00,
@@ -81,9 +133,6 @@ namespace quicr::messages {
         kTooFarBehind,
     };
 
-    Bytes& operator<<(Bytes& buffer, SubscribeDoneStatusCode value);
-    BytesSpan operator>>(BytesSpan buffer, SubscribeDoneStatusCode& value);
-
     enum class FetchType : uint8_t
     {
         kStandalone = 0x1,
@@ -104,9 +153,6 @@ namespace quicr::messages {
         kGoAwayTimeout = 0x10,
     };
 
-    Bytes& operator<<(Bytes& buffer, TerminationReason value);
-    BytesSpan operator>>(BytesSpan buffer, TerminationReason& value);
-
     enum class FetchErrorCode : uint8_t
     {
         kInternalError = 0x0,
@@ -129,9 +175,6 @@ namespace quicr::messages {
         kUninterested
     };
 
-    Bytes& operator<<(Bytes& buffer, AnnounceErrorCode value);
-    BytesSpan operator>>(BytesSpan buffer, AnnounceErrorCode& value);
-
     // TODO (Suhas): rename it to StreamMapping
     enum ForwardingPreference : uint8_t
     {
@@ -158,9 +201,6 @@ namespace quicr::messages {
         kTrackNotExist = 0xF0 // Missing in draft
     };
 
-    Bytes& operator<<(Bytes& buffer, SubscribeErrorCode value);
-    BytesSpan operator>>(BytesSpan buffer, SubscribeErrorCode& value);
-
     enum class SubscribeAnnouncesErrorCode : uint64_t
     {
         kInternalError = 0x0,
@@ -169,7 +209,4 @@ namespace quicr::messages {
         kNotSupported,
         kNamespacePrefixUnknown,
     };
-
-    Bytes& operator<<(Bytes& buffer, SubscribeAnnouncesErrorCode value);
-    BytesSpan operator>>(BytesSpan buffer, SubscribeAnnouncesErrorCode& value);
 } // namespace

src/ctrl_message_types.cpp

@@ -58,20 +58,6 @@ namespace quicr::messages {
         return buffer.subspan(value_uv.size());
     }
 
-    Bytes& operator<<(Bytes& buffer, ParameterType value)
-    {
-        buffer << UintVar(static_cast<std::uint64_t>(value));
-        return buffer;
-    }
-
-    BytesSpan operator>>(BytesSpan buffer, ParameterType& value)
-    {
-        std::uint64_t uvalue;
-        buffer = buffer >> uvalue;
-        value = static_cast<ParameterType>(uvalue);
-        return buffer;
-    }
-
     Bytes& operator<<(Bytes& buffer, GroupOrder value)
     {
         buffer << static_cast<std::uint64_t>(value);
@@ -86,20 +72,6 @@ namespace quicr::messages {
         return buffer;
     }
 
-    Bytes& operator<<(Bytes& buffer, FilterType value)
-    {
-        buffer << static_cast<std::uint64_t>(value);
-        return buffer;
-    }
-
-    BytesSpan operator>>(BytesSpan buffer, FilterType& value)
-    {
-        std::uint64_t uvalue;
-        buffer = buffer >> uvalue;
-        value = static_cast<FilterType>(uvalue);
-        return buffer;
-    }
-
     Bytes& operator<<(Bytes& buffer, FetchType value)
     {
         buffer << static_cast<std::uint64_t>(value);
@@ -114,34 +86,6 @@ namespace quicr::messages {
         return buffer;
     }
 
-    Bytes& operator<<(Bytes& buffer, AnnounceErrorCode value)
-    {
-        buffer << static_cast<std::uint64_t>(value);
-        return buffer;
-    }
-
-    BytesSpan operator>>(BytesSpan buffer, AnnounceErrorCode& value)
-    {
-        std::uint64_t uvalue;
-        buffer = buffer >> uvalue;
-        value = static_cast<AnnounceErrorCode>(uvalue);
-        return buffer;
-    }
-
-    Bytes& operator<<(Bytes& buffer, SubscribeAnnouncesErrorCode value)
-    {
-        buffer << static_cast<std::uint64_t>(value);
-        return buffer;
-    }
-
-    BytesSpan operator>>(BytesSpan buffer, SubscribeAnnouncesErrorCode& value)
-    {
-        std::uint64_t uvalue;
-        buffer = buffer >> uvalue;
-        value = static_cast<SubscribeAnnouncesErrorCode>(uvalue);
-        return buffer;
-    }
-
     Bytes& operator<<(Bytes& buffer, FetchErrorCode value)
     {
         buffer << static_cast<std::uint64_t>(value);
@@ -156,32 +100,4 @@ namespace quicr::messages {
         return buffer;
     }
 
-    Bytes& operator<<(Bytes& buffer, SubscribeDoneStatusCode value)
-    {
-        buffer << static_cast<std::uint64_t>(value);
-        return buffer;
-    }
-
-    BytesSpan operator>>(BytesSpan buffer, SubscribeDoneStatusCode& value)
-    {
-        std::uint64_t uvalue;
-        buffer = buffer >> uvalue;
-        value = static_cast<SubscribeDoneStatusCode>(uvalue);
-        return buffer;
-    }
-
-    Bytes& operator<<(Bytes& buffer, SubscribeErrorCode value)
-    {
-        buffer << static_cast<std::uint64_t>(value);
-        return buffer;
-    }
-
-    BytesSpan operator>>(BytesSpan buffer, SubscribeErrorCode& value)
-    {
-        std::uint64_t uvalue;
-        buffer = buffer >> uvalue;
-        value = static_cast<SubscribeErrorCode>(uvalue);
-        return buffer;
-    }
-
 }

test/moq_ctrl_messages.cpp

@@ -896,3 +896,86 @@ TEST_CASE("Subscribe Announces Error encode/decode")
     CHECK_EQ(msg.error_code, msg_out.error_code);
     CHECK_EQ(msg.reason_phrase, msg_out.reason_phrase);
 }
+
+using TestKVP64 = KeyValuePair<std::uint64_t>;
+enum class ExampleEnum : std::uint64_t
+{
+    kOdd = 1,
+    kEven = 2,
+};
+using TestKVPEnum = KeyValuePair<ExampleEnum>;
+Bytes
+kvp64(const std::uint64_t type, const Bytes& value)
+{
+    TestKVP64 test;
+    test.type = type;
+    test.value = value;
+    Bytes buffer;
+    buffer << test;
+    return buffer;
+}
+Bytes
+kvpEnum(const ExampleEnum type, const Bytes& value)
+{
+    TestKVPEnum test;
+    test.type = type;
+    test.value = value;
+    Bytes buffer;
+    buffer << test;
+    return buffer;
+}
+
+TEST_CASE("Key Value Pair encode/decode")
+{
+    auto value = Bytes(sizeof(std::uint64_t));
+    constexpr std::uint64_t one = 1;
+    std::memcpy(value.data(), &one, value.size());
+    {
+        CAPTURE("UINT64_T");
+        {
+            CAPTURE("EVEN");
+            std::size_t type = 2;
+            Bytes serialized = kvp64(type, value);
+            CHECK_EQ(serialized.size(), 2); // Minimal size, 1 byte for type and 1 byte for value.
+            TestKVP64 out;
+            serialized >> out;
+            CHECK_EQ(out.type, type);
+            CHECK_EQ(out.value, value);
+        }
+        {
+            CAPTURE("ODD");
+            std::size_t type = 1;
+            Bytes serialized = kvp64(type, value);
+            CHECK_EQ(serialized.size(),
+                     value.size() + 1 + 1); // 1 byte for type, 1 byte for length, and the value bytes.
+            TestKVP64 out;
+            serialized >> out;
+            CHECK_EQ(out.type, type);
+            CHECK_EQ(out.value, value);
+        }
+    }
+    {
+        CAPTURE("ENUM");
+        {
+            CAPTURE("EVEN");
+            auto type = ExampleEnum::kEven;
+            Bytes serialized = kvpEnum(type, value);
+            CHECK_EQ(serialized.size(), 2); // Minimal size, 1 byte for type and 1 byte for value.
+            TestKVPEnum out;
+            serialized >> out;
+            CHECK_EQ(out.type, type);
+            CHECK_EQ(out.value, value);
+        }
+        {
+            CAPTURE("ODD");
+            auto type = ExampleEnum::kOdd;
+            Bytes serialized = kvpEnum(type, value);
+            CHECK_EQ(serialized.size(),
+                     value.size() + 1 + 1); // 1 byte for type, 1 byte for length, and the value bytes.
+            TestKVPEnum out;
+            serialized >> out;
+            CHECK_EQ(out.type, type);
+            CHECK_EQ(out.value, value);
+        }
+    }
+}