ctrl_message_types.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "quicr/messages/uintvar.h"
#include "quicr/track_name.h"
 
#include <algorithm>
#include <limits>
#include <map>
#include <optional>
#include <source_location>
#include <stdexcept>
#include <string>
#include <tuple>
#include <variant>
 
namespace quicr {
    BytesSpan operator>>(BytesSpan buffer, TrackNamespace& msg);
 
    Bytes& operator<<(Bytes& buffer, const TrackNamespace& msg);
}
 
namespace quicr::messages {
 
    enum class ControlMessageType : uint64_t
    {
        kRequestUpdate = 0x2,          
        kSubscribe = 0x3,              
        kSubscribeOk = 0x4,            
        kRequestError = 0x5,           
        kPublishNamespace = 0x6,       
        kRequestOk = 0x7,              
        kNamespace = 0x8,              
        kPublishNamespaceDone = 0x9,   
        kUnsubscribe = 0xa,            
        kPublishDone = 0xb,            
        kPublishNamespaceCancel = 0xc, 
        kTrackStatus = 0xd,            
        kNamespaceDone = 0xe,          
        kPublishBlocked = 0xf,         
        kGoaway = 0x10,                
        kMaxRequestId = 0x15,          
        kFetch = 0x16,                 
        kFetchCancel = 0x17,           
        kFetchOk = 0x18,               
        kRequestsBlocked = 0x1a,       
        kPublish = 0x1d,               
        kSubscribeNamespace = 0x50,    
        kSubscribeTracks = 0x51,       
        kSetup = 0x2F00,               
    };
 
    struct ProtocolViolationException : std::runtime_error
    {
        const std::string reason; 
 
        ProtocolViolationException(const std::string& reason,
                                   const std::source_location location = std::source_location::current())
          : std::runtime_error("Protocol violation: " + reason + " (line " + std::to_string(location.line()) +
                               ", file " + location.file_name() + ")")
          , reason(reason)
        {
        }
    };
 
    Bytes& operator<<(Bytes& buffer, const Bytes& bytes);
 
    Bytes& operator<<(Bytes& buffer, const BytesSpan& bytes);
 
    BytesSpan operator>>(BytesSpan buffer, Bytes& value);
 
    Bytes& operator<<(Bytes& buffer, std::uint64_t value);
 
    BytesSpan operator>>(BytesSpan buffer, std::uint64_t& value);
 
    Bytes& operator<<(Bytes& buffer, std::uint8_t value);
 
    BytesSpan operator>>(BytesSpan buffer, uint8_t& value);
 
    Bytes& operator<<(Bytes& buffer, std::uint16_t value);
 
    BytesSpan operator>>(BytesSpan buffer, std::uint16_t& value);
 
    Bytes& operator<<(Bytes& buffer, const UintVar& value);
 
    struct Location
    {
        std::uint64_t group{ 0 };  
        std::uint64_t object{ 0 }; 
 
        auto operator<=>(const Location& other) const
        {
            if (const auto cmp = group <=> other.group; cmp != 0) {
                return cmp;
            }
            return object <=> other.object;
        }
 
        bool operator==(const Location& other) const = default;
    };
 
    Bytes& operator<<(Bytes& buffer, const Location& location);
 
    BytesSpan operator>>(BytesSpan buffer, Location& location);
 
    struct FetchEndLocation
    {
        std::uint64_t group{ 0 }; 
        std::optional<std::uint64_t>
          object; 
    };
 
    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; 
 
        std::size_t Size(const T prev_type) const
        {
            std::size_t size = 0;
            const auto type_value = static_cast<std::uint64_t>(type);
            const auto prev_type_value = static_cast<std::uint64_t>(prev_type);
            const auto delta = type_value - prev_type_value;
            size += UintVar(delta).size();
 
            if (type_value % 2 == 0) {
                // Even types: single varint of value
                if (value.size() > sizeof(std::uint64_t)) {
                    throw std::invalid_argument("Value too large to encode as uint64_t.");
                }
                std::uint64_t val = 0;
                std::memcpy(&val, value.data(), value.size());
                size += UintVar(val).size();
            } else {
                // Odd types: length + bytes
                size += UintVar(value.size()).size();
                size += value.size();
            }
            return size;
        }
 
        bool operator==(const KeyValuePair<T>& other) const
        {
            if (type != other.type) {
                return false;
            }
 
            if (static_cast<std::uint64_t>(type) % 2 != 0) {
                // Odd types are byte equality.
                return value == other.value;
            }
 
            // Even types are numeric equality.
            if (value.size() > sizeof(std::uint64_t) || other.value.size() > sizeof(std::uint64_t)) {
                throw std::invalid_argument("Even KVPs must be <= 8 bytes");
            }
 
            // Compare numeric values.
            const auto smaller = std::min(value.size(), other.value.size());
            if (memcmp(value.data(), other.value.data(), smaller) != 0) {
                return false;
            }
 
            // Are there left over bytes to check?
            const auto larger = std::max(value.size(), other.value.size());
            if (larger == smaller) {
                return true;
            }
 
            // Any remaining bytes could be 0, but nothing else.
            const auto& longer = (value.size() > other.value.size()) ? value : other.value;
            const auto remaining = larger - smaller;
            static constexpr std::uint8_t kZero[sizeof(std::uint64_t)] = { 0 };
            return memcmp(longer.data() + smaller, kZero, remaining) == 0;
        }
    };
 
    template<KeyType T>
    Bytes& operator<<(Bytes& buffer, const T value)
    {
        return buffer << UintVar(static_cast<std::uint64_t>(value));
    }
 
    template<KeyType T>
    BytesSpan operator>>(BytesSpan buffer, T& value)
    {
        std::uint64_t uvalue;
        buffer = buffer >> uvalue;
        value = static_cast<T>(uvalue);
        return buffer;
    }
 
    template<KeyType T>
    void SerializeKvp(Bytes& buffer, const KeyValuePair<T>& kvp, const T prev_type)
    {
        // Delta encode the type.
        const auto type_value = static_cast<std::uint64_t>(kvp.type);
        const auto prev_type_value = static_cast<std::uint64_t>(prev_type);
        const auto delta = type_value - prev_type_value;
        buffer << UintVar(delta);
 
        if (type_value % 2 != 0) {
            // Odd, encode bytes.
            buffer << kvp.value;
        } else {
            // Even, single varint of value.
            if (kvp.value.size() > sizeof(std::uint64_t)) {
                throw std::invalid_argument("Value too large to encode as uint64_t.");
            }
            std::uint64_t val = 0;
            std::memcpy(&val, kvp.value.data(), kvp.value.size());
            buffer << UintVar(val);
        }
    }
 
    template<KeyType T>
    void ParseKvp(BytesSpan& buffer, KeyValuePair<T>& kvp, const T prev_type)
    {
        // Delta to absolute.
        const auto prev_type_value = static_cast<std::uint64_t>(prev_type);
        std::uint64_t delta;
        buffer = buffer >> delta;
        if (delta > std::numeric_limits<std::uint64_t>::max() - prev_type_value) {
            throw ProtocolViolationException("Delta encoding overflow: prev_type + delta exceeds 2^64-1");
        }
        const auto type_value = prev_type_value + delta;
        kvp.type = static_cast<T>(type_value);
 
        if (type_value % 2 != 0) {
            // Odd, decode bytes.
            buffer = buffer >> kvp.value;
        } else {
            // Even, decode single varint of value.
            UintVar uvar(buffer);
            buffer = buffer.subspan(uvar.size());
            std::uint64_t val(uvar);
            const auto* p = reinterpret_cast<const std::uint8_t*>(&val);
            kvp.value.assign(p, p + sizeof(val));
        }
    }
 
    enum struct SetupOptionType : uint64_t
    {
        kPath = 0x01,                  
        kAuthorizationToken = 0x03,    
        kMaxAuthTokenCacheSize = 0x04, 
        kAuthority = 0x05,             
        kMoqtImplementation = 0x07,    
 
        /*===================================================================*/
        // Internal Use
        /*===================================================================*/
 
        kEndpointId = 0xF1, 
        kInvalid = 0xFF,    
    };
 
    struct Token
    {
        enum class AliasType : std::uint64_t
        {
            kDelete = 0x0,   
            kRegister = 0x1, 
            kUseAlias = 0x2, 
            kUseValue = 0x3, 
        };
 
        AliasType alias_type{ AliasType::kUseValue }; 
 
        std::optional<std::uint64_t> token_alias;
 
        std::optional<std::uint64_t> token_type;
 
        Bytes token_value;
 
        bool operator==(const Token& other) const = default;
    };
 
    inline Bytes& operator<<(Bytes& buffer, const Token& token)
    {
        buffer << UintVar(static_cast<std::uint64_t>(token.alias_type));
        switch (token.alias_type) {
            case Token::AliasType::kDelete:
            case Token::AliasType::kUseAlias:
                buffer << UintVar(token.token_alias.value());
                break;
            case Token::AliasType::kRegister:
                buffer << UintVar(token.token_alias.value());
                buffer << UintVar(token.token_type.value());
                AppendBytes(buffer, token.token_value);
                break;
            case Token::AliasType::kUseValue:
                buffer << UintVar(token.token_type.value());
                AppendBytes(buffer, token.token_value);
                break;
        }
        return buffer;
    }
 
    inline BytesSpan operator>>(BytesSpan buffer, Token& token)
    {
        std::uint64_t alias_type = 0;
        buffer = buffer >> alias_type;
        token.alias_type = static_cast<Token::AliasType>(alias_type);
 
        switch (token.alias_type) {
            case Token::AliasType::kDelete:
            case Token::AliasType::kUseAlias: {
                std::uint64_t alias = 0;
                buffer = buffer >> alias;
                token.token_alias = alias;
                break;
            }
            case Token::AliasType::kRegister: {
                std::uint64_t alias = 0;
                std::uint64_t type = 0;
                buffer = buffer >> alias;
                buffer = buffer >> type;
                token.token_alias = alias;
                token.token_type = type;
                token.token_value.assign(buffer.begin(), buffer.end());
                buffer = buffer.subspan(buffer.size());
                break;
            }
            case Token::AliasType::kUseValue: {
                std::uint64_t type = 0;
                buffer = buffer >> type;
                token.token_type = type;
                token.token_value.assign(buffer.begin(), buffer.end());
                buffer = buffer.subspan(buffer.size());
                break;
            }
            default:
                throw ProtocolViolationException("Invalid AUTHORIZATION_TOKEN alias type");
        }
        return buffer;
    }
 
    enum struct GroupOrder : uint8_t
    {
        kAscending = 0x1, 
        kDescending = 0x2 
    };
 
    Bytes& operator<<(Bytes& buffer, GroupOrder value);
 
    BytesSpan operator>>(BytesSpan buffer, GroupOrder& value);
 
    enum struct FilterType : uint64_t
    {
        kNone,               
        kSubscriptionFilter, 
        kTrackFilter,        
    };
 
    enum class SubscriptionFilterType : std::uint64_t
    {
        kNextGroupStart = 0x1, 
        kLargestObject = 0x2,  
        kAbsoluteStart = 0x3,  
        kAbsoluteRange = 0x4,  
    };
 
    struct SubscriptionFilter
    {
        SubscriptionFilterType type{ SubscriptionFilterType::kNextGroupStart };
 
        Location start_location{};
 
        std::uint64_t end_group_delta{ 0 };
 
        auto operator<=>(const SubscriptionFilter&) const noexcept = default;
    };
 
    inline Bytes& operator<<(Bytes& bytes, const SubscriptionFilter& filter)
    {
        bytes << UintVar(static_cast<std::uint64_t>(filter.type));
        switch (filter.type) {
            case SubscriptionFilterType::kNextGroupStart:
            case SubscriptionFilterType::kLargestObject:
                break;
            case SubscriptionFilterType::kAbsoluteStart:
                bytes << filter.start_location;
                break;
            case SubscriptionFilterType::kAbsoluteRange:
                if (filter.end_group_delta > std::numeric_limits<std::uint64_t>::max() - filter.start_location.group) {
                    throw ProtocolViolationException("Subscription filter end group overflow");
                }
                bytes << filter.start_location << UintVar(filter.end_group_delta);
                break;
            default:
                throw ProtocolViolationException("Invalid subscription filter type");
        }
        return bytes;
    }
 
    inline BytesSpan operator>>(BytesSpan bytes, SubscriptionFilter& filter)
    {
        filter = SubscriptionFilter{};
        std::uint64_t type = 0;
        bytes = bytes >> type;
        filter.type = static_cast<SubscriptionFilterType>(type);
        switch (filter.type) {
            case SubscriptionFilterType::kNextGroupStart:
            case SubscriptionFilterType::kLargestObject:
                break;
            case SubscriptionFilterType::kAbsoluteStart:
                bytes = bytes >> filter.start_location;
                break;
            case SubscriptionFilterType::kAbsoluteRange:
                bytes = bytes >> filter.start_location >> filter.end_group_delta;
                if (filter.end_group_delta > std::numeric_limits<std::uint64_t>::max() - filter.start_location.group) {
                    throw ProtocolViolationException("Subscription filter end group overflow");
                }
                break;
            default:
                throw ProtocolViolationException("Invalid subscription filter type");
        }
        return bytes;
    }
 
    struct TrackFilter
    {
        std::uint64_t property_type;       
        std::uint64_t max_tracks_selected; 
        std::uint64_t timeout;             
 
        constexpr auto operator<=>(const TrackFilter& other) const noexcept = default;
    };
 
    inline Bytes& operator<<(Bytes& bytes, const TrackFilter& filter)
    {
        AppendBytes(bytes, UintVar(filter.property_type));
        AppendBytes(bytes, UintVar(filter.max_tracks_selected));
        AppendBytes(bytes, UintVar(filter.timeout));
 
        return bytes;
    }
 
    inline BytesSpan operator>>(BytesSpan bytes, TrackFilter& filter)
    {
        bytes = bytes >> filter.property_type;
        bytes = bytes >> filter.max_tracks_selected;
        bytes = bytes >> filter.timeout;
 
        return bytes;
    }
 
    using Filter = std::variant<std::monostate, SubscriptionFilter, TrackFilter>;
 
    inline FilterType GetFilterType(const Filter& filter)
    {
        return std::visit(
          [](auto&& f) {
              using T = std::decay_t<decltype(f)>;
              if constexpr (std::is_same_v<std::monostate, T>) {
                  return FilterType::kNone;
              } else if constexpr (std::is_same_v<SubscriptionFilter, T>) {
                  return FilterType::kSubscriptionFilter;
              } else if constexpr (std::is_same_v<TrackFilter, T>) {
                  return FilterType::kTrackFilter;
              }
          },
          filter);
    }
 
    inline Bytes& operator<<(Bytes& bytes, const Filter& filter)
    {
        std::visit(
          [&](auto&& f) {
              using T = std::decay_t<decltype(f)>;
              if constexpr (!std::is_same_v<std::monostate, T>) {
                  bytes << f;
              }
          },
          filter);
        return bytes;
    }
 
    inline BytesSpan operator>>(BytesSpan, Filter&)
    {
        throw std::runtime_error("parsing a non specific filter is impossible, stream to a more specific filter type");
    }
 
    inline Filter DeserializeFilter(FilterType filter_type, BytesSpan bytes)
    {
        switch (filter_type) {
            case FilterType::kSubscriptionFilter: {
                SubscriptionFilter filter{};
                bytes = bytes >> filter;
                if (!bytes.empty()) {
                    throw ProtocolViolationException("Trailing bytes in subscription filter");
                }
                return filter;
            }
            case FilterType::kTrackFilter: {
                TrackFilter filter{};
                bytes = bytes >> filter;
                return filter;
            }
            default:
                return std::monostate{};
        }
 
        return std::monostate{};
    }
 
    enum class PublishDoneStatusCode : uint64_t
    {
        kInternalError = 0x0,     
        kUnauthorized = 0x1,      
        kTrackEnded = 0x2,        
        kSubscriptionEnded = 0x3, 
        kGoingAway = 0x4,         
        kTooFarBehind = 0x5,      
        kExpired = 0x6,
        kMalformedTrack = 0x12,
        kUpdateFailed = 0x8,
        kExcessiveLoad = 0x9
    };
 
    Bytes& operator<<(Bytes& buffer, PublishDoneStatusCode value);
 
    BytesSpan operator>>(BytesSpan buffer, PublishDoneStatusCode& value);
 
    enum class FetchType : uint8_t
    {
        kStandalone = 0x1,     
        kRelativeJoiningFetch, 
        kAbsoluteJoiningFetch  
    };
 
    Bytes& operator<<(Bytes& buffer, FetchType value);
 
    BytesSpan operator>>(BytesSpan buffer, FetchType& value);
 
    enum class TerminationReason : uint64_t
    {
        kNoError = 0x0,                   
        kInternalError = 0x1,             
        kUnauthorized = 0x2,              
        kProtocolViolation = 0x3,         
        kInvalidRequestId = 0x4,          
        kDuplicateTrackAlias = 0x5,       
        kKeyValueFormattingError = 0x6,   
        kTooManyRequests = 0x7,           
        kInvalidPath = 0x8,               
        kMalformedPath = 0x9,             
        kGoawayTimeout = 0x10,            
        kControlMessageTimeout = 0x11,    
        kDataStreamTimeout = 0x12,        
        kAuthTokenCacheOverflow = 0x13,   
        kDuplicateAuthTokenAlias = 0x14,  
        kVersionNegotiationFailed = 0x15, 
        kMalformedAuthToken = 0x16,       
        kUnknownAuthTokenAlias = 0x17,    
        kExpiredAuthToken = 0x18,         
        kInvalidAuthority = 0x19,         
        kMalformedAuthority = 0x1A,       
    };
 
    enum class StreamResetError : uint64_t
    {
        kInternalError = 0x0,       
        kCancelled = 0x1,           
        kDeliveryTimeout = 0x2,     
        kSessionClosed = 0x3,       
        kUnknownObjectStatus = 0x4, 
        kMalformedTrack = 0x12,     
    };
 
    enum class ExtensionType : uint64_t
    {
        // Track Scope Extensions
        kDeliveryTimeout = 0x02,            
        kMaxCacheDuration = 0x04,           
        kDefaultPublisherPriority = 0x0E,   
        kDefaultPublisherGroupOrder = 0x22, 
        kDynamicGroups = 0x30,              
 
        // Object Scope Extensions
        kPriorGroupIdGap = 0x3C,  
        kPriorObjectIdGap = 0x3E, 
 
        // Dual Scope (Track and Object) Extensions
        kImmutable = 0x0B, 
    };
 
    template<class T>
    concept HasByteStreamOperators = requires(T& value, Bytes& bytes) {
        { bytes << value } -> std::same_as<Bytes&>;
        { BytesSpan{} >> value } -> std::same_as<BytesSpan>;
    };
 
    template<class T>
    concept ByteParameter = std::is_convertible_v<T, std::uint8_t> ||
                            (std::is_enum_v<T> && std::same_as<std::underlying_type_t<T>, std::uint8_t>);
 
    class KeyValuePairs
    {
      public:
        KeyValuePairs() = default;
 
        KeyValuePairs(const std::map<std::uint64_t, Bytes>& pairs)
          : pairs_(pairs)
        {
        }
 
        template<typename T, KeyType K>
        KeyValuePairs& Add(K type, const T& value)
        {
            const auto type_value = static_cast<std::uint64_t>(type);
            pairs_[type_value] = EncodeValue(type_value, value);
            return *this;
        }
 
        template<typename T, KeyType K>
        std::optional<T> Get(K type) const
        {
            const auto it = pairs_.find(static_cast<std::uint64_t>(type));
            if (it == pairs_.end()) {
                return std::nullopt;
            }
            const auto& bytes = it->second;
            if constexpr (std::is_arithmetic_v<T>) {
                if (static_cast<std::uint64_t>(type) % 2 == 0) {
                    std::uint64_t val = 0;
                    std::memcpy(&val, bytes.data(), std::min(bytes.size(), sizeof(val)));
                    return static_cast<T>(val);
                }
            }
 
            if constexpr (HasByteStreamOperators<T>) {
                T result;
                bytes >> result;
                return result;
            }
 
            return FromBytes<T>(bytes);
        }
 
        bool Contains(std::uint64_t type) const { return pairs_.contains(type); }
 
        auto begin() const noexcept { return pairs_.begin(); }
 
        auto end() const noexcept { return pairs_.end(); }
 
        const std::map<std::uint64_t, Bytes>& Pairs() const noexcept { return pairs_; }
 
        template<typename T>
        static Bytes EncodeValue(std::uint64_t type, const T& value)
        {
            if constexpr (std::is_arithmetic_v<T> || std::is_enum_v<T>) {
                if (type % 2 == 0) {
                    const std::uint64_t val = static_cast<std::uint64_t>(value);
                    auto* val_bytes = reinterpret_cast<const std::uint8_t*>(&val);
                    return Bytes{ val_bytes, val_bytes + sizeof(val) };
                }
            }
 
            if constexpr (HasByteStreamOperators<T>) {
                Bytes bytes;
                bytes << value;
                return bytes;
            }
 
            return AsOwnedBytes(value);
        }
 
      private:
        std::map<std::uint64_t, Bytes> pairs_;
    };
 
    BytesSpan operator>>(BytesSpan buffer, KeyValuePairs& msg);
 
    Bytes& operator<<(Bytes& buffer, const KeyValuePairs& msg);
 
    class TrackExtensions
    {
      public:
        TrackExtensions() = default;
 
        TrackExtensions(const std::map<std::uint64_t, Bytes>& ext)
          : extensions(ext)
        {
        }
 
      public:
        template<typename T>
        TrackExtensions& Add(ExtensionType type, const T& value)
        {
            if (type == ExtensionType::kImmutable) {
                throw std::invalid_argument("ExtensionType::kImmutable should not be used directly, use AddImmutable "
                                            "with the keytype you want to use");
            }
 
            extensions[static_cast<std::uint64_t>(type)] =
              KeyValuePairs::EncodeValue(static_cast<std::uint64_t>(type), value);
 
            return *this;
        }
 
        template<typename T>
        TrackExtensions& AddOptional(ExtensionType type, const std::optional<T>& value)
        {
            if (value.has_value()) {
                Add<T>(type, value.value());
            }
            return *this;
        }
 
        template<typename T>
        TrackExtensions& AddImmutable(ExtensionType type, const T& value)
        {
            immutable_extensions[static_cast<std::uint64_t>(type)] =
              KeyValuePairs::EncodeValue(static_cast<std::uint64_t>(type), value);
            return *this;
        }
 
        template<typename T>
        std::optional<T> Get(ExtensionType type) const
        {
            if (!extensions.contains(static_cast<std::uint64_t>(type))) {
                return std::nullopt;
            }
            if constexpr (std::is_arithmetic_v<T>) {
                if (static_cast<std::uint64_t>(type) % 2 == 0) {
                    std::uint64_t val = 0;
                    const auto& bytes = extensions.at(static_cast<std::uint64_t>(type));
                    std::memcpy(&val, bytes.data(), std::min(bytes.size(), sizeof(val)));
                    return static_cast<T>(val);
                }
            }
 
            if constexpr (HasByteStreamOperators<T>) {
                T result;
                extensions.at(static_cast<std::uint64_t>(type)) >> result;
                return result;
            }
 
            return FromBytes<T>(extensions.at(static_cast<std::uint64_t>(type)));
        }
 
        template<typename T>
        std::optional<T> GetImmutable(ExtensionType type) const
        {
            if (!immutable_extensions.contains(static_cast<std::uint64_t>(type))) {
                return std::nullopt;
            }
            if constexpr (std::is_arithmetic_v<T>) {
                if (static_cast<std::uint64_t>(type) % 2 == 0) {
                    std::uint64_t val = 0;
                    const auto& bytes = immutable_extensions.at(static_cast<std::uint64_t>(type));
                    std::memcpy(&val, bytes.data(), std::min(bytes.size(), sizeof(val)));
                    return static_cast<T>(val);
                }
            }
 
            if constexpr (HasByteStreamOperators<T>) {
                T result;
                immutable_extensions.at(static_cast<std::uint64_t>(type)) >> result;
                return result;
            }
 
            return FromBytes<T>(immutable_extensions.at(static_cast<std::uint64_t>(type)));
        }
 
        auto begin() const noexcept { return extensions.begin(); }
 
        auto end() const noexcept { return extensions.end(); }
 
        std::map<std::uint64_t, Bytes> extensions;           
        std::map<std::uint64_t, Bytes> immutable_extensions; 
    };
 
    BytesSpan operator>>(BytesSpan buffer, TrackExtensions& msg);
 
    Bytes& operator<<(Bytes& buffer, const TrackExtensions& msg);
 
} // namespace