unsharable_shared_ptr.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <mutable/util/exception.hpp>
#include <mutable/util/macro.hpp>
 
 
namespace m {
 
template<typename T>
struct unsharable_shared_ptr : public std::shared_ptr<T>
{
    template<typename To, typename From> friend unsharable_shared_ptr<To> cast(unsharable_shared_ptr<From>);
    template<typename To, typename From> friend unsharable_shared_ptr<To> as(unsharable_shared_ptr<From>);
 
    using super = std::shared_ptr<T>;
    /* Must not add `using super::super` or `super::operator=` since this would allow construction or assignment from
     * a `std::shared_ptr` which we want to prevent because a custom deleter might not be set.  Instead, explicitly
     * implement the desired methods by delegating to the superclass and delete the undesired methods. */
 
    private:
    using deleter_func_type = void(*)(const void*);
    static void default_deleter(const void *ptr) { delete (T*) ptr; }
    static void noop_deleter(const void*) { }
 
    public:
    template<typename Y>
    explicit unsharable_shared_ptr(Y *ptr) : super(ptr, &unsharable_shared_ptr::default_deleter) { }
 
    unsharable_shared_ptr() : super(nullptr) { }
    explicit unsharable_shared_ptr(std::nullptr_t) : super(nullptr) { }
 
    unsharable_shared_ptr(const unsharable_shared_ptr&) = default;
    unsharable_shared_ptr(unsharable_shared_ptr&&) = default;
 
    template<typename Y>
    unsharable_shared_ptr(const unsharable_shared_ptr<Y> &ptr) : super(ptr) { }
    template<typename Y>
    unsharable_shared_ptr(unsharable_shared_ptr<Y> &&ptr) : super(std::move(ptr)) { }
 
    template<typename Y>
    unsharable_shared_ptr(const std::shared_ptr<Y>&) = delete; // delete since custom deleter might not be set
    private:
    /* Conceptually deleted, since custom deleter might not be set but must be possible for befriended `cast()` and
     * `as()`. */
    template<typename Y>
    unsharable_shared_ptr(std::shared_ptr<Y> &&ptr) : super(std::move(ptr)) { }
 
    public:
    unsharable_shared_ptr & operator=(const unsharable_shared_ptr&) = default;
    unsharable_shared_ptr & operator=(unsharable_shared_ptr&&) = default;
 
    template<typename Y>
    unsharable_shared_ptr & operator=(const unsharable_shared_ptr<Y> &ptr) { super::operator=(ptr); return *this; }
    template<typename Y>
    unsharable_shared_ptr & operator=(unsharable_shared_ptr<Y> &&ptr) { super::operator=(std::move(ptr)); return *this; }
 
    template<typename Y>
    unsharable_shared_ptr & operator=(const std::shared_ptr<Y>&) = delete; // delete since custom deleter might not be set
    template<typename Y>
    unsharable_shared_ptr & operator=(std::shared_ptr<Y>&&) = delete; // delete since custom deleter might not be set
 
    std::unique_ptr<T> exclusive_shared_to_unique() {
        if (super::use_count() == 0) return nullptr;  // nothing to unshare
        if (super::use_count() > 1) throw m::invalid_state{"not exclusive"};
        *std::get_deleter<deleter_func_type>(static_cast<super>(*this)) = &unsharable_shared_ptr::noop_deleter;
        std::unique_ptr<T> uptr{super::get()};
        super::reset();  // this will *not* delete the referenced object
        M_insist(super::get() == nullptr);
        return uptr;
    }
};
 
template<typename T, typename... Args>
unsharable_shared_ptr<T> make_unsharable_shared(Args&&... args)
{
    return unsharable_shared_ptr<T>{new T(std::forward<Args>(args)...)};
}
 
}