unique_ptr_object.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/throw_helper.hpp"
#define __XTD_CORE_INTERNAL__
#include "internal/__array_definition.hpp"
#include "internal/__list_definition.hpp"
#include "internal/__unique_ptr_object_definition.hpp"
#undef __XTD_CORE_INTERNAL__
#include "hash_code.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "null_ptr.hpp"
#include "object.hpp"
#include <memory>

namespace xtd {
  namespace linq {
    class enumerable;
  }
  
  
  template<class type_t, class deleter_t>
  class unique_ptr_object : public xtd::object, public xtd::icomparable<unique_ptr_object<type_t, deleter_t>>, public xtd::iequatable<unique_ptr_object<type_t, deleter_t >> {
  public:
    
    using base_type = std::unique_ptr<type_t, deleter_t>;
    using deleter_type = typename base_type::deleter_type;
    using element_type = typename base_type::element_type;
    using pointer_type = typename base_type::pointer;
    
    
    static const unique_ptr_object empty;
    
    
    unique_ptr_object() noexcept = default;
    unique_ptr_object(xtd::null_ptr null) noexcept : ptr_ {null} {} // Can't be explicit by design.
    explicit unique_ptr_object(pointer_type ptr) noexcept : ptr_ {ptr} {}
    unique_ptr_object(pointer_type ptr, const deleter_t& deleter) noexcept : ptr_ {ptr, deleter} {}
    unique_ptr_object(pointer_type ptr, deleter_t&& deleter) noexcept : ptr_ {ptr, deleter} {}
    unique_ptr_object(unique_ptr_object&& value) noexcept : ptr_ {std::move(value.ptr_)} {}
    template<class value_t, class other_deleter_t>
    unique_ptr_object(unique_ptr_object<value_t, other_deleter_t>&& value) : ptr_ {std::move(value)} {}
    template<class value_t, class other_deleter_t>
    unique_ptr_object(std::unique_ptr<value_t, other_deleter_t>&& value) : ptr_ {std::move(value)} {}
    unique_ptr_object(const unique_ptr_object& value) = delete;
    unique_ptr_object(const base_type& value) = delete;
    
    template<class pointer_t>
    explicit unique_ptr_object(pointer_t* ptr) noexcept : ptr_ {ptr} {}
    template<class pointer_t, class other_deleter_t>
    unique_ptr_object(pointer_t* ptr, other_deleter_t deleter) noexcept : ptr_ {ptr, deleter} {}
    
    template<class value_t>
    unique_ptr_object(unique_ptr_object<value_t>&& value) noexcept : ptr_ {std::move(value.ptr_)} {}
    unique_ptr_object(base_type&& value) noexcept : ptr_ {std::move(value)} {}
    template<class value_t>
    unique_ptr_object(std::unique_ptr<value_t>&& value) noexcept : ptr_ {std::move(value)} {}
    
    
    const base_type& pointer() const noexcept {return ptr_;}
    base_type& pointer() noexcept {return ptr_;}
    
    
    int32 compare_to(const unique_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 unique_ptr_object*>(&value) && equals(static_cast<const unique_ptr_object&>(value));}
    bool equals(const unique_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);}
    
    pointer_type release() noexcept {return ptr_.release();}
    
    void reset() noexcept {ptr_.reset();}
    void reset(pointer_type ptr) noexcept {ptr_.reset(ptr);}
    template<class pointer_t>
    void reset(pointer_t* ptr) noexcept {ptr_.reset(ptr);}
    void reset(xtd::null_ptr null) noexcept {ptr_.reset(null);}
    
    
    void swap(unique_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;
    
    
    unique_ptr_object& operator =(unique_ptr_object&& value) noexcept {
      ptr_ = std::move(value.ptr_);
      return *this;
    }
    
    template<class value_t>
    unique_ptr_object& operator =(unique_ptr_object<value_t>&& value) noexcept {
      ptr_ = std::move(value.ptr_);
      return *this;
    }
    
    template<class value_t>
    unique_ptr_object& operator =(std::unique_ptr<value_t>&& value) noexcept {
      ptr_ = std::move(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();}
    
  private:
    template<class value_t, class other_deleter_t>
    friend class xtd::unique_ptr_object;
    
    template<class value_t, class allocator_t>
    friend class xtd::basic_array;
    
    template<class value_t, class allocator_t>
    friend class xtd::collections::generic::list;
    
    friend class xtd::linq::enumerable;
    
    unique_ptr_object& operator =(const unique_ptr_object& value) noexcept {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);}
    
    base_type ptr_;
  };
  
  template<class type_t, class deleter_t>
  inline const unique_ptr_object<type_t, deleter_t>  unique_ptr_object<type_t, deleter_t>::empty;
  
  // C++17 deduction guides for xtd::reference_wrapper_object
  // {
  template<class type_t>
  unique_ptr_object(type_t*) -> unique_ptr_object<type_t, std::default_delete<type_t>>;
  template<class type_t, class deleter_t>
  unique_ptr_object(type_t*, const deleter_t&) -> unique_ptr_object<type_t, deleter_t>;
  template<class type_t, class deleter_t>
  unique_ptr_object(xtd::unique_ptr_object<type_t, deleter_t>()) -> unique_ptr_object<type_t, deleter_t>;
  template<class type_t, class deleter_t>
  unique_ptr_object(std::unique_ptr<type_t, deleter_t>()) -> unique_ptr_object<type_t, deleter_t>;
  // }
}
 
template<class object_t>
xtd::unique_ptr_object<object_t> xtd::object::memberwise_clone() const {
  auto object_ptr = dynamic_cast<const object_t*>(this);
  if (object_ptr == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
  return xtd::unique_ptr_object<object_t>(new object_t(*object_ptr));
}