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 <memory>
 
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;
 
    
    inline 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>
    shared_ptr_object(pointer_t* ptr) noexcept : ptr_ {ptr} {}
    template<class value_t>
    explicit shared_ptr_object(shared_ptr_object<value_t>&& value) noexcept : ptr_ {std::move(value.ptr_)} {}
    template<class value_t>
    explicit shared_ptr_object(const shared_ptr_object<value_t>& value) noexcept : ptr_ {value.ptr_} {}
    template<class value_t>
    explicit shared_ptr_object(base_type&& value) noexcept : ptr_ {std::move(value)} {}
    template<class value_t>
    explicit shared_ptr_object(const std::shared_ptr<value_t>& value) noexcept : ptr_ {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);}
 
    base_type pointer() const 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(*ptr_) : 0);}
 
    void reset() noexcept {ptr_.reset();}
    template<class pointer_t>
    void reset(pointer_t* ptr) noexcept {ptr_.reset(ptr);}
 
    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;
    
    type_t* 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_;}
 
  private:
    template<class other_t>
    friend class shared_ptr_object;
    mutable base_type ptr_;
  };
}