subscribe_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/subscribe_track_handler.h"
#include "quicr/track_name.h"
 
#include <map>
#include <memory>
 
namespace quicr {
 
    class Session;
 
    class SubscribeNamespaceHandler : public TrackHandler
    {
      public:
        enum class Mode
        {
            kNamespaces, 
            kTracks      
        };
 
        enum class Status : uint8_t
        {
            kOk = 0,        
            kNotSubscribed, 
            kError,         
        };
 
      protected:
        SubscribeNamespaceHandler(const TrackNamespace& prefix,
                                  Mode mode,
                                  const messages::Filter& filter = std::monostate{});
 
      public:
        static auto Create(const TrackNamespace& prefix,
                           const Mode mode,
                           const messages::Filter& filter = std::monostate{})
        {
            return std::shared_ptr<SubscribeNamespaceHandler>(new SubscribeNamespaceHandler(prefix, mode, filter));
        }
 
        virtual ~SubscribeNamespaceHandler();
 
        virtual void StatusChanged(Status status);
 
        const TrackNamespace& GetPrefix() const noexcept { return prefix_; }
 
        messages::FilterType GetFilterType() const noexcept { return messages::GetFilterType(filter_); }
 
        constexpr const messages::Filter& GetFilter() const noexcept { return filter_; }
 
        constexpr Status GetStatus() const noexcept { return status_; }
 
        std::optional<Error<ErrorCode>> GetError() const noexcept { return error_; }
 
        constexpr Mode GetMode() const noexcept { return mode_; }
 
        TrackNamespace ExpandSuffix(const TrackNamespace& suffix) const;
 
      protected:
        virtual void NamespaceReceived([[maybe_unused]] const TrackNamespace& name_space) {}
 
        virtual void NamespaceDoneReceived([[maybe_unused]] const TrackNamespace& name_space) {}
 
        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) });
        }
 
      private:
        const Mode mode_; 
 
        const TrackNamespace prefix_; 
 
        messages::Filter filter_; 
 
        Status status_{ Status::kNotSubscribed };
 
        std::optional<Error<ErrorCode>> error_{};
 
        friend class Session;
    };
}