shared_ptr.h

Go to the documentation of this file.

#pragma once
#include "y3c/terminate.h"
#include "y3c/wrap.h"
#include "y3c/typename.h"
#include <memory>
 
namespace y3c {
 
template <typename T>
class shared_ptr {
    std::shared_ptr<T> base_;
    std::shared_ptr<internal::life> ptr_life_;
    internal::life life_;
 
    const std::string &type_name() const {
        return internal::get_type_name<shared_ptr>();
    }
 
  public:
    shared_ptr(std::nullptr_t = nullptr) noexcept
        : base_(nullptr), ptr_life_(nullptr), life_(this) {}
    shared_ptr(const shared_ptr &other)
        : base_(other.base_), ptr_life_(other.ptr_life_), life_(this) {}
    shared_ptr &operator=(const shared_ptr &other) {
        if (this != std::addressof(other)) {
            base_ = other.base_;
            ptr_life_ = other.ptr_life_;
        }
        return *this;
    }
    shared_ptr(shared_ptr &&other)
        : base_(std::move(other.base_)), ptr_life_(std::move(other.ptr_life_)),
          life_(this) {}
    shared_ptr &operator=(shared_ptr &&other) {
        if (this != std::addressof(other)) {
            base_ = std::move(other.base_);
            ptr_life_ = std::move(other.ptr_life_);
        }
        return *this;
    }
    ~shared_ptr() = default;
 
    using element_type = T;
 
    template <typename U>
    shared_ptr(const std::shared_ptr<U> &ptr)
        : base_(ptr), ptr_life_(std::make_shared<internal::life>(base_.get())),
          life_(this) {}
    template <typename U>
    shared_ptr &operator=(const std::shared_ptr<U> &ptr) {
        base_ = ptr;
        ptr_life_ = std::make_shared<internal::life>(base_.get());
        return *this;
    }
    template <typename U>
    shared_ptr(std::shared_ptr<U> &&ptr)
        : base_(std::move(ptr)),
          ptr_life_(std::make_shared<internal::life>(base_.get())),
          life_(this) {}
    template <typename U>
    shared_ptr &operator=(std::shared_ptr<U> &&ptr) {
        base_ = std::move(ptr);
        ptr_life_ = std::make_shared<internal::life>(base_.get());
        return *this;
    }
 
    template <typename U>
    shared_ptr(const shared_ptr<U> &other)
        : base_(other.base_), ptr_life_(other.ptr_life_), life_(this) {}
    template <typename U>
    shared_ptr &operator=(const shared_ptr<U> &other) {
        base_ = other.base_;
        ptr_life_ = other.ptr_life_;
        return *this;
    }
    template <typename U>
    shared_ptr(shared_ptr<U> &&other)
        : base_(std::move(other.base_)), ptr_life_(std::move(other.ptr_life_)),
          life_(this) {}
    template <typename U>
    shared_ptr &operator=(shared_ptr<U> &&other) {
        base_ = std::move(other.base_);
        ptr_life_ = std::move(other.ptr_life_);
        return *this;
    }
 
    template <typename U>
    friend class shared_ptr;
 
    void reset() noexcept {
        base_.reset();
        ptr_life_.reset();
    }
    void swap(shared_ptr &other) noexcept {
        base_.swap(other.base_);
        ptr_life_.swap(other.ptr_life_);
    }
 
    ptr<element_type> get() const noexcept {
        if (!base_) {
            return nullptr;
        }
        y3c_assert_internal(ptr_life_);
        return ptr<element_type>(base_.get(), ptr_life_->observer());
    }
    template <typename E = element_type, typename = internal::skip_trace_tag>
    y3c::wrap_ref<E> operator*() const {
        if (!base_) {
            static std::string func = type_name() + "::operator*()";
            y3c::internal::terminate_ub_access_nullptr(func);
        }
        y3c_assert_internal(ptr_life_);
        return y3c::wrap_ref<E>(base_.get(), ptr_life_->observer());
    }
    template <typename = internal::skip_trace_tag>
    element_type *operator->() const {
        if (!base_) {
            static std::string func = type_name() + "::operator->()";
            y3c::internal::terminate_ub_access_nullptr(func);
        }
        y3c_assert_internal(ptr_life_);
        return base_.get();
    }
    // template <typename U = T>
    // U &operator[](std::ptrdiff_t i) const {
    //     if (i < 0 || todo)
    //     return check_()[i];
    // }
 
    long use_count() const noexcept { return base_.use_count(); }
    explicit operator bool() const noexcept { return static_cast<bool>(base_); }
    bool owner_before(const shared_ptr &arg) const {
        return base_.owner_before(arg.base_);
    }
 
    operator const std::shared_ptr<T> &() const noexcept { return base_; }
 
    operator wrap<const shared_ptr &>() const noexcept {
        return wrap<const shared_ptr &>(this, life_.observer());
    }
    wrap<const shared_ptr *> operator&() const {
        return wrap<const shared_ptr *>(this, life_.observer());
    }
};
 
template <typename T>
const std::shared_ptr<T> &unwrap(const shared_ptr<T> &wrapper) noexcept {
    return static_cast<const std::shared_ptr<T> &>(wrapper);
}
 
template <typename T>
void swap(shared_ptr<T> &lhs, shared_ptr<T> &rhs) noexcept {
    lhs.swap(rhs);
}
 
template <typename T, typename U>
bool operator==(const shared_ptr<T> &lhs, const shared_ptr<U> &rhs) noexcept {
    return unwrap(lhs) == unwrap(rhs);
}
template <typename T, typename U>
bool operator!=(const shared_ptr<T> &lhs, const shared_ptr<U> &rhs) noexcept {
    return unwrap(lhs) != unwrap(rhs);
}
template <typename T, typename U>
bool operator<(const shared_ptr<T> &lhs, const shared_ptr<U> &rhs) noexcept {
    return unwrap(lhs) < unwrap(rhs);
}
template <typename T, typename U>
bool operator<=(const shared_ptr<T> &lhs, const shared_ptr<U> &rhs) noexcept {
    return unwrap(lhs) <= unwrap(rhs);
}
template <typename T, typename U>
bool operator>(const shared_ptr<T> &lhs, const shared_ptr<U> &rhs) noexcept {
    return unwrap(lhs) > unwrap(rhs);
}
template <typename T, typename U>
bool operator>=(const shared_ptr<T> &lhs, const shared_ptr<U> &rhs) noexcept {
    return unwrap(lhs) >= unwrap(rhs);
}
 
template <class CharT, class Traits, typename T>
std::basic_ostream<CharT, Traits> &
operator<<(std::basic_ostream<CharT, Traits> &os, const shared_ptr<T> &p) {
    return os << unwrap(p);
}
 
template <typename T, typename... Args>
shared_ptr<T> make_shared(Args &&...args) {
    return shared_ptr<T>(std::make_shared<T>(std::forward<Args>(args)...));
}
 
} // namespace y3c