reply.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/transport.h"
#include "quicr/utilities/expected.h"
 
#include <concepts>
#include <functional>
#include <thread>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace quicr {
 
    template<typename T, typename E>
    class Reply
    {
      public:
        using ResultType = Expected<T, Error<E>>;
 
        using CompletionType = std::function<void(ResultType)>;
 
        using DeferType = std::function<void(CompletionType&&)>;
 
      private:
        Reply(DeferType&& action)
          : result_(std::in_place_type<DeferType>, std::move(action))
        {
        }
 
        bool IsDeferred() const noexcept { return std::holds_alternative<DeferType>(result_); }
 
      public:
        Reply() = default;
 
        Reply(const Reply& other) = delete;
 
        Reply(Reply&& other) noexcept = default;
 
        Reply& operator=(const Reply& other) = delete;
 
        Reply& operator=(Reply&& other) noexcept = default;
 
        template<typename U>
            requires(!std::same_as<std::remove_cvref_t<U>, Reply> && std::is_constructible_v<ResultType, U &&>)
        Reply(U&& value)
          : result_(std::in_place_type<ResultType>, std::forward<U>(value))
        {
        }
 
        static Reply Defer(DeferType&& action) { return Reply(std::move(action)); }
 
        template<typename F>
        void Resolve(const std::shared_ptr<Transport>& transport, F&& f)
        {
            if (IsDeferred()) {
                auto action = std::move(std::get<DeferType>(result_));
                action([transport, f = std::forward<F>(f)](ResultType reply) mutable {
                    transport->QueueDeferredReply(
                      [result = std::move(reply), f = std::forward<F>(f)]() mutable { f(result); });
                });
                return;
            }
 
            f(std::move(std::get<ResultType>(result_)));
        }
 
      private:
        std::variant<ResultType, DeferType> result_;
    };
}