back_ref_mixin.hpp

 
#pragma once
 
#include <memory>
#include <utility>
 
#include <rapidsmpf/error.hpp>
#include <rapidsmpf/utils/misc.hpp>
 
namespace rapidsmpf {
 
template <typename BackRef>
class BackRefMixin {
  public:
    BackRefMixin() noexcept = default;
 
    BackRefMixin(BackRefMixin const& other)
        : weak_{other.weak_},
          strong_{other.strong_ ? other.strong_ : std::shared_ptr<BackRef>{other.weak_}} {
    }
 
    BackRefMixin& operator=(BackRefMixin const& other) {
        if (this != &other) {
            // Promote first so a throw leaves *this unchanged.
            auto promoted =
                other.strong_ ? other.strong_ : std::shared_ptr<BackRef>{other.weak_};
            weak_ = other.weak_;
            strong_ = std::move(promoted);
        }
        return *this;
    }
 
    BackRefMixin(BackRefMixin&&) noexcept = default;
 
    BackRefMixin& operator=(BackRefMixin&&) noexcept = default;
 
    ~BackRefMixin() = default;
 
    [[nodiscard]] bool operator==(BackRefMixin const& other) const noexcept {
        return owner_equal(weak_, other.weak_);
    }
 
    void set_backref(std::weak_ptr<BackRef> backref) {
        std::weak_ptr<BackRef> const empty_weak{};
        RAPIDSMPF_EXPECTS(
            !owner_equal(backref, empty_weak),
            "set_backref: backref must not be empty",
            std::invalid_argument
        );
        RAPIDSMPF_EXPECTS(
            owner_equal(weak_, empty_weak),
            "set_backref: backref is already set",
            std::invalid_argument
        );
        weak_ = std::move(backref);
        strong_.reset();
    }
 
  private:
    std::weak_ptr<BackRef> weak_{};
    std::shared_ptr<BackRef> strong_{};
};
 
}  // namespace rapidsmpf