Added track_status_request_message

raven/includes/serialization/deserialization_impl.hpp

@@ -348,4 +348,29 @@ deserialize(rvn::SubscribeErrorMessage& subscribeErrorMessage, ConstSpan& span,
     return deserializedBytes;
 }
 
+template <typename ConstSpan>
+static inline deserialize_return_t
+deserialize(rvn::TrackStatusRequestMessage& trackStatusRequestMessage,
+            ConstSpan& span,
+            NetworkEndian = network_endian)
+{
+    std::uint64_t deserializedBytes = 0;
+
+    std::uint64_t trackNameSpaceLength;
+    deserializedBytes += deserialize<ds::quic_var_int>(trackNameSpaceLength, span);
+
+    trackStatusRequestMessage.trackNamespace_ =
+    std::string(span.data(), span.data() + trackNameSpaceLength);
+    span.advance_begin(trackNameSpaceLength);
+
+    std::uint64_t trackNameLength;
+    deserializedBytes += deserialize<ds::quic_var_int>(trackNameLength, span);
+
+    trackStatusRequestMessage.trackName_ =
+    std::string(span.data(), span.data() + trackNameLength);
+    span.advance_begin(trackNameLength);
+
+    return deserializedBytes;
+}
+
 } // namespace rvn::serialization::detail

raven/includes/serialization/messages.hpp

@@ -431,10 +431,24 @@ struct AnnounceCancelMessage
       Track Name (b),
     }
 */
-struct TrackStatusRequestMessage
+struct TrackStatusRequestMessage : public ControlMessageBase<TrackStatusRequestMessage>
 {
-    BinaryBufferData trackNamespace;
-    BinaryBufferData trackName;
+    std::string trackNamespace_;
+    std::string trackName_;
+
+    TrackStatusRequestMessage()
+    : ControlMessageBase(MoQtMessageType::TRACK_STATUS_REQUEST)
+    {
+    }
+
+    bool operator==(const TrackStatusRequestMessage&) const = default;
+
+    friend inline std::ostream&
+    operator<<(std::ostream& os, const TrackStatusRequestMessage& msg)
+    {
+        os << "TrackNamespace: " << msg.trackNamespace_ << "TrackName: " << msg.trackName_;
+        return os;
+    }
 };
 
 enum class ObjectStatus : iType

raven/includes/serialization/serialization_impl.hpp

@@ -143,6 +143,7 @@ template <UnsignedInteger T>
  serialize_return_t serialize(ds::chunk& c, const StreamHeaderSubgroupObject& msg);
  serialize_return_t serialize(ds::chunk& c, const rvn::SubscribeErrorMessage& subscribeErrorMessage);
  serialize_return_t serialize(ds::chunk& c, const rvn::BatchSubscribeMessage& batchSubscribeMessage);
+ serialize_return_t serialize(ds::chunk& c, const rvn::TrackStatusRequestMessage& trackStatusRequestMessage);
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // clang-format on
 } // namespace rvn::serialization::detail

raven/src/serialization_impl.cpp

@@ -306,4 +306,36 @@ serialize(ds::chunk& c, const rvn::BatchSubscribeMessage& batchSubscribeMessage)
 
     return headerLen + msgLen;
 }
+
+serialize_return_t
+serialize(ds::chunk& c, const rvn::TrackStatusRequestMessage& trackStatusRequestMessage)
+{
+    std::uint64_t msgLen = 0;
+    // we need to find out the length of the message we would be serializing
+    {
+        msgLen += mock_serialize<ds::quic_var_int>(
+        trackStatusRequestMessage.trackNamespace_.size());
+        msgLen += trackStatusRequestMessage.trackNamespace_.size();
+
+        msgLen +=
+        mock_serialize<ds::quic_var_int>(trackStatusRequestMessage.trackName_.size());
+        msgLen += trackStatusRequestMessage.trackName_.size();
+    }
+    // Header
+    std::uint64_t headerLen = 0;
+    headerLen +=
+    serialize<ds::quic_var_int>(c, utils::to_underlying(MoQtMessageType::TRACK_STATUS_REQUEST));
+    headerLen += serialize<ds::quic_var_int>(c, msgLen);
+
+    // Body
+    serialize<ds::quic_var_int>(c, trackStatusRequestMessage.trackNamespace_.size());
+    c.append(trackStatusRequestMessage.trackNamespace_.data(),
+             trackStatusRequestMessage.trackNamespace_.size());
+
+    serialize<ds::quic_var_int>(c, trackStatusRequestMessage.trackName_.size());
+    c.append(trackStatusRequestMessage.trackName_.data(),
+             trackStatusRequestMessage.trackName_.size());
+
+    return headerLen + msgLen;
+}
 } // namespace rvn::serialization::detail

tests/serialization/CMakeLists.txt

@@ -5,3 +5,4 @@ add_raven_test(serialize_server_setup_message.cpp)
 add_raven_test(serialize_subscribe_message.cpp)
 add_raven_test(serialize_subscribe_error_message.cpp)
 add_raven_test(serialize_batch_subscribe_message.cpp)
+add_raven_test(serialize_track_status_request_message.cpp)

tests/serialization/serialize_track_status_request_message.cpp

@@ -0,0 +1,70 @@
+#include "test_serialization_utils.hpp"
+#include "utilities.hpp"
+#include <serialization/chunk.hpp>
+#include <serialization/deserialization_impl.hpp>
+#include <serialization/messages.hpp>
+#include <serialization/serialization_impl.hpp>
+
+using namespace rvn;
+using namespace rvn::serialization;
+
+
+void test1()
+{
+    TrackStatusRequestMessage msg;
+    msg.trackNamespace_ = "h";
+    msg.trackName_ = "i";
+
+    ds::chunk c;
+    serialization::detail::serialize(c, msg);
+    // clang-format off
+    // [ 00001101 ]            [ 00000100 ]   [ 00000001 01101000 ]     [ 00000001 01101001 ]
+    // (quic_msg_type: 0xD)    (msglen = 4)     (trackNameSpace)             (trackName)
+    std::string expectedSerializationString = "[00001101][00000100][00000001 01101000][00000001 01101001]";
+    // clang-format on
+
+    auto expectedSerialization = binary_string_to_vector(expectedSerializationString);
+    utils::ASSERT_LOG_THROW(c.size() == expectedSerialization.size(), "Size mismatch\n",
+                            "Expected size: ", expectedSerialization.size(),
+                            "\n", "Actual size: ", c.size(), "\n");
+    for (std::size_t i = 0; i < c.size(); i++)
+        utils::ASSERT_LOG_THROW(c[i] == expectedSerialization[i], "Mismatch at index: ", i,
+                                "\n", "Expected: ", expectedSerialization[i],
+                                "\n", "Actual: ", c[i], "\n");
+
+    ds::ChunkSpan span(c);
+
+    ControlMessageHeader header;
+    serialization::detail::deserialize(header, span);
+
+    utils::ASSERT_LOG_THROW(header.messageType_ == MoQtMessageType::TRACK_STATUS_REQUEST,
+                            "Message type mismatch\n", "Expected: ",
+                            utils::to_underlying(MoQtMessageType::TRACK_STATUS_REQUEST), "\n",
+                            "Actual: ", utils::to_underlying(header.messageType_), "\n");
+
+    TrackStatusRequestMessage deserializedMsg;
+    serialization::detail::deserialize(deserializedMsg, span);
+
+    utils::ASSERT_LOG_THROW(msg == deserializedMsg, "Deserialization failed\n",
+                            "Expected: ", msg, "\n", "Actual: ", deserializedMsg, "\n");
+}
+
+void tests()
+{
+    try
+    {
+        test1();
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "Test failed\n";
+        std::cerr << e.what() << std::endl;
+    }
+}
+
+
+int main()
+{
+    tests();
+    return 0;
+}