attributes.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2025 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "quicr/messages/ctrl_message_types.h"
#include "quicr/track_name.h"
#include "quicr/utilities/bytes.h"
 
#include <chrono>
#include <optional>
 
namespace quicr {
    struct TrackStatusResponse
    {
        std::optional<messages::Location> largest_location{};
 
        messages::TrackExtensions track_properties{}; 
    };
 
    struct PublishNamespaceAttributes
    {
        std::uint64_t request_id{ 0 }; 
    };
 
    struct SetupAttributes
    {
        std::string endpoint_id;
    };
 
    // TODO: Maybe split base attributes out from SUBSCRIBE / PUBLISH?
    // TODO: E.g priority, new_group_request_id.
 
    struct PublishOkAttributes
    {
        const std::optional<std::uint8_t> subscriber_priority;
 
        const std::optional<messages::GroupOrder> group_order;
 
        const messages::Filter filter; 
 
        const std::optional<bool> forward;
 
        const std::optional<std::chrono::milliseconds> subgroup_delivery_timeout;
 
        const std::optional<std::chrono::milliseconds> object_delivery_timeout;
 
        const std::optional<std::uint64_t> new_group_request_id;
    };
 
    struct SubscribeAttributes
    {
        std::uint8_t priority{ 0 };                      
        std::optional<messages::GroupOrder> group_order; 
        messages::GroupOrder publisher_default_group_order{
            messages::GroupOrder::kAscending
        }; 
        std::chrono::milliseconds delivery_timeout{ 0 }; 
        std::chrono::milliseconds expires{ 0 };          
        messages::Filter filter{ std::monostate{} };     
        std::uint8_t forward{ 0 };                       
        std::optional<uint64_t> new_group_request_id;    
        bool is_publisher_initiated{ false }; 
        messages::Location start_location{};  
        std::chrono::milliseconds rendezvous_timeout{ 0 }; 
    };
 
    struct PublishAttributes
    {
        const FullTrackName track_full_name; 
 
        const std::uint64_t track_alias; 
 
        const std::vector<messages::Token> auth_tokens; 
 
        const std::optional<std::uint64_t> expires;
 
        const std::optional<messages::Location> largest_object;
 
        const bool forward; 
 
        const messages::GroupOrder default_publisher_group_order; 
 
        const bool dynamic_groups; 
 
        const std::uint8_t publisher_priority;
 
        const std::optional<std::uint64_t> max_cache_duration;
 
        const std::optional<std::uint64_t> delivery_timeout;
 
        const messages::TrackExtensions track_properties; 
    };
 
    struct StandaloneFetchAttributes
    {
        std::uint8_t priority{ 0 };                      
        std::optional<messages::GroupOrder> group_order; 
        messages::GroupOrder publisher_default_group_order{
            messages::GroupOrder::kAscending
        }; 
        messages::Location start_location{};       
        messages::FetchEndLocation end_location{}; 
    };
 
    struct JoiningFetchAttributes
    {
        std::uint8_t priority{ 0 };                      
        std::optional<messages::GroupOrder> group_order; 
        messages::GroupOrder publisher_default_group_order{
            messages::GroupOrder::kAscending
        }; 
        std::uint64_t joining_request_id{ 0 }; 
        bool relative{ false };           
        std::uint64_t joining_start{ 0 }; 
    };
 
    struct SubscribeNamespaceAttributes
    {
        uint64_t request_id{ 0 }; 
 
        messages::FilterType filter_type{
            messages::FilterType::kTrackFilter
        }; 
 
        messages::Filter filter{ std::monostate{} }; 
    };
 
    struct Redirect
    {
        std::string uri;
        TrackNamespace track_namespace;
        std::optional<Bytes> track_name;
        std::optional<std::uint64_t> request_id;
    };
 
}