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<class 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<class pointer_t>
    explicit shared_ptr_object(pointer_t* ptr) noexcept : ptr_ {ptr} {}
    template<class value_t>
    shared_ptr_object(shared_ptr_object<value_t>&& value) noexcept : ptr_ {std::move(value.ptr_)} {}
    template<class 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<class value_t>
    shared_ptr_object(const std::shared_ptr<value_t>& value) noexcept : ptr_ {value} {}
    template<class value_t>
    explicit shared_ptr_object(const std::weak_ptr<value_t>& value) noexcept : ptr_ {value} {}
    template<class value_t, class deleter_t>
    shared_ptr_object(xtd::unique_ptr_object<value_t, deleter_t>&& value) : ptr_ {std::move(value.pointer())} {}
    template<class value_t, class deleter_t>
    shared_ptr_object(std::unique_ptr<value_t, deleter_t>&& value) : ptr_ {std::move(value)} {}
    
    
    bool is_unique() const noexcept {return use_count() == xtd::size {1};}
    
    template<class value_t>
    bool owner_before(const shared_ptr_object<value_t>& other) const noexcept {return ptr_.owner_before(other.ptr_);}
    template<class value_t>
    bool owner_before(const std::shared_ptr<value_t>& other) const noexcept {return ptr_.owner_before(other);}
    template<class value_t>
    bool owner_before( const std::weak_ptr<value_t>& other) const noexcept {return ptr_.owner_before(other);}
    
    const base_type& pointer() const noexcept {return ptr_;}
    
    base_type& pointer() noexcept {return ptr_;}
    
    xtd::size use_count() const noexcept {return static_cast<xtd::size>(ptr_.use_count());}
    
    
    int32 compare_to(const shared_ptr_object& obj) const noexcept override {return to_pointer() < obj.to_pointer() ? -1 : to_pointer() > obj.to_pointer() ? 1 : 0;}
    
    bool equals(const xtd::object& value) const noexcept override {return dynamic_cast<const shared_ptr_object*>(&value) && equals(static_cast<const shared_ptr_object&>(value));}
    bool equals(const shared_ptr_object& value) const noexcept override {return ptr_ == value.ptr_;}
    
    element_type* get() const noexcept {return ptr_.get();}
    
    xtd::size get_hash_code() const noexcept override {return (ptr_ ? xtd::hash_code::combine(to_pointer()) : 0);}
    
    void reset() noexcept {ptr_.reset();}
    template<class pointer_t>
    void reset(pointer_t* ptr) noexcept {ptr_.reset(ptr);}
    void reset(xtd::null_ptr null) noexcept {ptr_.reset();}
    
    void swap(shared_ptr_object& ptr) noexcept {ptr_.swap(ptr.ptr_);}
    
    type_t& to_object() const noexcept {return *to_pointer();}
    
    template<typename target_t>
    target_t to_object() const;
    
    element_type* to_pointer() const noexcept {return get();}
    
    template<typename target_t>
    target_t* to_pointer() const;
    
    xtd::string to_string() const noexcept override;
    
    
    shared_ptr_object& operator =(shared_ptr_object&& value) noexcept {
      ptr_ = std::move(value.ptr_);
      return *this;
    }
    
    shared_ptr_object& operator =(const shared_ptr_object& value) noexcept {
      ptr_ = value.ptr_;
      return *this;
    }
    
    template<class value_t>
    shared_ptr_object& operator =(shared_ptr_object<value_t>&& value) noexcept {
      ptr_ = std::move(value.ptr_);
      return *this;
    }
    
    template<class value_t>
    shared_ptr_object& operator =(const shared_ptr_object<value_t>& value) noexcept {
      ptr_ = value.ptr_;
      return *this;
    }
    
    template<class value_t>
    shared_ptr_object& operator =(std::shared_ptr<value_t>&& value) noexcept {
      ptr_ = std::move(value);
      return *this;
    }
    
    template<class value_t>
    shared_ptr_object& operator =(const std::shared_ptr<value_t>& value) noexcept {
      ptr_ = value;
      return *this;
    }
    
    type_t& operator *() const noexcept {return ptr_.operator *();}
    
    type_t* operator ->() const noexcept {return ptr_.operator ->();}
    
    element_type& operator[](std::ptrdiff_t index) const {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<class other_t>
    friend class shared_ptr_object;
    base_type ptr_;
  };
  
  template<class type_t>
  inline const shared_ptr_object<type_t>  shared_ptr_object<type_t>::empty;
  
  // C++17 deduction guides for xtd::reference_wrapper_object
  // {
  template<class type_t>
  shared_ptr_object(type_t*) -> shared_ptr_object<type_t>;
  template<class type_t>
  shared_ptr_object(std::weak_ptr<type_t>()) -> shared_ptr_object<type_t>;
  template<class type_t, class deleter_t>
  shared_ptr_object(xtd::unique_ptr_object<type_t, deleter_t>()) -> shared_ptr_object<type_t>;
  template<class type_t, class deleter_t>
  shared_ptr_object(std::unique_ptr<type_t, deleter_t>()) -> shared_ptr_object<type_t>;
  // }
}