publish_namespace_handler.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/errors.h"
#include "quicr/handlers/publish_track_handler.h"
#include "quicr/track_name.h"
 
#include <map>
#include <memory>
 
namespace quicr {
 
    class Session;
 
    class PublishNamespaceHandler : public TrackHandler
    {
      public:
        enum class Status : uint8_t
        {
            kOk = 0,               
            kNotConnected,         
            kNotPublished,         
            kPendingResponse,      
            kPublishNotAuthorized, 
            kSendingDone,          
            kError,                
        };
 
      protected:
        PublishNamespaceHandler(const TrackNamespace& prefix);
 
        virtual void StatusChanged(Status status);
 
      public:
        static auto Create(const TrackNamespace& prefix)
        {
            return std::shared_ptr<PublishNamespaceHandler>(new PublishNamespaceHandler(prefix));
        }
 
        virtual ~PublishNamespaceHandler();
 
        virtual void PublishTrack(std::shared_ptr<PublishTrackHandler> handler);
 
        virtual void UnPublishTrack(std::shared_ptr<PublishTrackHandler> handler);
 
        virtual PublishTrackHandler::PublishObjectStatus PublishObject(
          uint64_t track_alias,
          const ObjectHeaders& object_headers,
          BytesSpan data,
          std::optional<messages::StreamHeaderProperties> stream_mode = std::nullopt);
 
        virtual PublishTrackHandler::PublishObjectStatus ForwardPublishedData(
          [[maybe_unused]] uint64_t track_alias,
          [[maybe_unused]] bool is_new_stream,
          [[maybe_unused]] uint64_t group_id,
          [[maybe_unused]] uint64_t subgroup_id,
          [[maybe_unused]] std::shared_ptr<const std::vector<uint8_t>> data)
        {
            return PublishTrackHandler::PublishObjectStatus::kInternalError;
        }
 
        const TrackNamespace& GetPrefix() const noexcept { return prefix_; }
 
        constexpr Status GetStatus() const noexcept { return status_; }
 
        std::optional<Error<ErrorCode>> GetError() const noexcept { return error_; }
 
      protected:
        void SetStatus(const Status status) noexcept
        {
            status_ = status;
            if (status == Status::kError && !error_.has_value()) {
                error_ = Error<ErrorCode>{ ErrorCode::kInternalError, "Unknown error" };
            }
 
            StatusChanged(status);
        }
 
        void SetError(const Error<ErrorCode>& error)
        {
            error_ = error;
            SetStatus(Status::kError);
        }
 
        void RequestOkReceived(const messages::Parameters& params) override;
 
        Reply<messages::Parameters, ErrorCode> RequestUpdateReceived(const messages::Parameters& params) override;
 
        void RequestError(ErrorCode error_code, std::string reason) override
        {
            SetError(Error<ErrorCode>{ error_code, std::move(reason) });
        }
 
        std::map<std::uint64_t, std::shared_ptr<PublishTrackHandler>> handlers_;
 
      private:
        const TrackNamespace prefix_; 
 
        Status status_{ Status::kNotPublished };
 
        std::optional<Error<ErrorCode>> error_{};
 
        friend class Session;
    };
}