refcount.h

Go to the documentation of this file.

#ifndef BASE_CORE_REFCOUNT_H_
#define BASE_CORE_REFCOUNT_H_
 
#include <atomic>
#include <memory>
#include <iostream>
 
namespace base {
namespace core {
 
class counted_base {
 public:
    counted_base();
 
    void ref() const;
 
    bool unref() const;
 
    int_fast32_t ref_count() const;
 
    bool ref_count_is_one() const;
 
 protected:
    virtual ~counted_base() {}
 
 private:
    mutable std::atomic_int_fast32_t ref_;
    counted_base(const counted_base&) = delete;
    void operator=(const counted_base&) = delete;
};
 
struct ref_count_deleter {
    void operator()(const counted_base* o) const {
        o->unref();
    }
};
 
template <typename T>
class ref_count_ptr;
 
template <typename T>
std::unique_ptr<T, ref_count_deleter> get_new_ref(T* ptr) {
    static_assert(std::is_base_of<counted_base, T>::value,
                  "T must be derived from counted_base");
 
    if (ptr == nullptr) {
        return std::unique_ptr<T, ref_count_deleter>();
    }
    ptr->ref();
    return std::unique_ptr<T, ref_count_deleter>(ptr);
}
 
template <typename T>
class ref_count_ptr : public std::unique_ptr<T, ref_count_deleter> {
 public:
    using std::unique_ptr<T, ref_count_deleter>::unique_ptr;
 
    std::unique_ptr<T, ref_count_deleter> get_new_ref() const {
        if (this->get() == nullptr) {
            return std::unique_ptr<T, ref_count_deleter>();
        }
        this->get()->ref();
        return std::unique_ptr<T, ref_count_deleter>(this->get());
    }
};
 
} // namespace core
} // namespace base
 
#endif // BASE_CORE_REFCOUNT_H_