shared_ptr_object.hpp

Go to the documentation of this file.

#pragma once
#include "hash_code.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "null_ptr.hpp"
#include "object.hpp"
#include "unique_ptr_object.hpp"

namespace xtd {
  
  template<typename type_t>
  class shared_ptr_object : public xtd::object, public xtd::icomparable<shared_ptr_object<type_t>>, public xtd::iequatable<shared_ptr_object<type_t >> {
  public:
    
    using base_type = std::shared_ptr<type_t>;
    using element_type = typename base_type::element_type;
    using weak_type = typename base_type::weak_type;
    
    
    static const shared_ptr_object empty;
    
    
    shared_ptr_object() noexcept = default;
    shared_ptr_object(xtd::null_ptr null) noexcept : ptr_ {null} {} // Can't be explicit by design.
    shared_ptr_object(shared_ptr_object&& value) noexcept : ptr_ {std::move(value.ptr_)} {}
    shared_ptr_object(const shared_ptr_object& value) noexcept : ptr_ {value.ptr_} {}
    template<typename pointer_t>
    explicit shared_ptr_object(pointer_t* ptr) noexcept : ptr_ {ptr} {}
    template<typename value_t>
    shared_ptr_object(shared_ptr_object<value_t>&& value) noexcept : ptr_ {std::move(value.ptr_)} {}
    template<typename value_t>
    shared_ptr_object(const shared_ptr_object<value_t>& value) noexcept : ptr_ {value.ptr_} {}
    shared_ptr_object(const base_type& value) noexcept : ptr_ {value} {}
    shared_ptr_object(base_type&& value) noexcept : ptr_ {std::move(value)} {}
    template<typename value_t>
    shared_ptr_object(const std::shared_ptr<value_t>& value) noexcept : ptr_ {value} {}
    template<typename value_t>
    explicit shared_ptr_object(const std::weak_ptr<value_t>& value) noexcept : ptr_ {value} {}
    template<typename value_t, typename deleter_t>
    shared_ptr_object(xtd::unique_ptr_object<value_t, deleter_t>&& value) : ptr_ {std::move(value.pointer())} {}
    template<typename value_t, typename deleter_t>
    shared_ptr_object(std::unique_ptr<value_t, deleter_t>&& value) : ptr_ {std::move(value)} {}
    
    
    [[nodiscard]] auto is_unique() const noexcept -> bool {return use_count() == xtd::usize {1};}
    
    template<typename value_t>
    [[nodiscard]] auto owner_before(const shared_ptr_object<value_t>& other) const noexcept -> bool {return ptr_.owner_before(other.ptr_);}
    template<typename value_t>
    [[nodiscard]] auto owner_before(const std::shared_ptr<value_t>& other) const noexcept -> bool {return ptr_.owner_before(other);}
    template<typename value_t>
    [[nodiscard]] auto owner_before(const std::weak_ptr<value_t>& other) const noexcept -> bool {return ptr_.owner_before(other);}
    
    [[nodiscard]] auto pointer() const noexcept -> const base_type& {return ptr_;}
    
    [[nodiscard]] auto pointer() noexcept -> base_type& {return ptr_;}
    
    [[nodiscard]] auto use_count() const noexcept -> xtd::usize {return static_cast<xtd::usize>(ptr_.use_count());}
    
    
    [[nodiscard]] auto compare_to(const shared_ptr_object& obj) const noexcept -> xtd::int32 override {return to_pointer() < obj.to_pointer() ? -1 : to_pointer() > obj.to_pointer() ? 1 : 0;}
    
    [[nodiscard]] auto equals(const xtd::object& value) const noexcept -> bool override {return dynamic_cast<const shared_ptr_object*>(&value) && equals(static_cast<const shared_ptr_object&>(value));}
    [[nodiscard]] auto equals(const shared_ptr_object& value) const noexcept -> bool override {return ptr_ == value.ptr_;}
    
    [[nodiscard]] auto get() const noexcept -> element_type* {return ptr_.get();}
    
    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override {return (ptr_ ? xtd::hash_code::combine(to_pointer()) : 0);}
    
    auto reset() noexcept -> void {ptr_.reset();}
    template<typename pointer_t>
    auto reset(pointer_t* ptr) noexcept -> void {ptr_.reset(ptr);}
    auto reset(xtd::null_ptr null) noexcept -> void {ptr_.reset();}
    
    auto swap(shared_ptr_object& ptr) noexcept -> void {ptr_.swap(ptr.ptr_);}
    
    [[nodiscard]] auto to_object() const noexcept -> type_t& {return *to_pointer();}
    
    template<typename target_t>
    [[nodiscard]] auto to_object() const -> target_t;
    
    [[nodiscard]] auto to_pointer() const noexcept -> element_type* {return get();}
    
    template<typename target_t>
    [[nodiscard]] auto to_pointer() const -> target_t*;
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    
    
    auto operator =(shared_ptr_object&& value) noexcept -> shared_ptr_object& {
      ptr_ = std::move(value.ptr_);
      return *this;
    }
    
    auto operator =(const shared_ptr_object& value) noexcept -> shared_ptr_object& {
      ptr_ = value.ptr_;
      return *this;
    }
    
    template<typename value_t>
    auto operator =(shared_ptr_object<value_t>&& value) noexcept -> shared_ptr_object& {
      ptr_ = std::move(value.ptr_);
      return *this;
    }
    
    template<typename value_t>
    auto operator =(const shared_ptr_object<value_t>& value) noexcept -> shared_ptr_object& {
      ptr_ = value.ptr_;
      return *this;
    }
    
    template<typename value_t>
    auto operator =(std::shared_ptr<value_t>&& value) noexcept -> shared_ptr_object& {
      ptr_ = std::move(value);
      return *this;
    }
    
    template<typename value_t>
    auto operator =(const std::shared_ptr<value_t>& value) noexcept -> shared_ptr_object& {
      ptr_ = value;
      return *this;
    }
    
    auto operator *() const noexcept -> type_t& {return ptr_.operator * ();}
    
    auto operator ->() const noexcept -> type_t* {return ptr_.operator ->();}
    
    auto operator[](std::ptrdiff_t index) const -> element_type& {return ptr_.operator [](index);}
    
    explicit operator bool() const noexcept {return ptr_.operator bool();}
    
    operator base_type() const noexcept {return ptr_;}
    
    operator weak_type() const noexcept {return weak_type {ptr_};}
    
  private:
    template<typename other_t>
    friend class shared_ptr_object;
    base_type ptr_;
  };
  
  template<typename type_t>
  inline const shared_ptr_object<type_t>  shared_ptr_object<type_t>::empty;
  
  // Deduction guides for xtd::reference_wrapper_object
  // {
  template<typename type_t>
  shared_ptr_object(type_t*) -> shared_ptr_object<type_t>;
  template<typename type_t>
  shared_ptr_object(std::weak_ptr<type_t>()) -> shared_ptr_object<type_t>;
  template<typename type_t, typename deleter_t>
  shared_ptr_object(xtd::unique_ptr_object<type_t, deleter_t>()) -> shared_ptr_object<type_t>;
  template<typename type_t, typename deleter_t>
  shared_ptr_object(std::unique_ptr<type_t, deleter_t>()) -> shared_ptr_object<type_t>;
  // }
}