cpp-descriptive-pointers/include/pointers/value_ptr.hpp

//
//  copy_ptr.hpp
//  pointers
//
//  Created by Sam Jaffe on 12/6/16.
//

#pragma once

#include <memory>

#include "pointer_fwd.hpp"
#include "ptr_compare.hpp"

namespace detail {
  template <typename T> using clone_func = T * (T::*)() const;

  template <typename T, typename = void> class value_ptr_copy;

  template <typename T>
  struct value_ptr_copy<T, std::enable_if_t<!std::is_polymorphic<T>::value>> {
    T * Copy(T * ptr) const { return ptr ? new T(*ptr) : nullptr; }
  };

#define POLYMORPHIC_VALUE_PTR_GROUP_FROM_CLONE_FUNCTION(fclone)                \
  template <typename T>                                                        \
  struct value_ptr_copy<                                                       \
      T, std::enable_if_t<                                                     \
             std::is_polymorphic<T>::value &&                                  \
             std::is_same<clone_func<T>, decltype(&T::fclone)>::value>> {      \
    T * Copy(T * ptr) const { return ptr ? ptr->fclone() : nullptr; }          \
  }

  POLYMORPHIC_VALUE_PTR_GROUP_FROM_CLONE_FUNCTION(Clone);
  POLYMORPHIC_VALUE_PTR_GROUP_FROM_CLONE_FUNCTION(clone);
  POLYMORPHIC_VALUE_PTR_GROUP_FROM_CLONE_FUNCTION(Copy);
  POLYMORPHIC_VALUE_PTR_GROUP_FROM_CLONE_FUNCTION(copy);
}

template <typename T> class value_ptr : private detail::value_ptr_copy<T> {
public:
  using element_type = T;
  using pointer = element_type *;
  using reference = element_type &;

  value_ptr() noexcept : _ptr(nullptr) {}
  value_ptr(T * const & p) = delete;
  value_ptr(T *&& p) noexcept(detail::is_nt_mc<T>::value)
      : _ptr(std::move(p)) {}
  value_ptr(value_ptr const & other)
      : _ptr(detail::value_ptr_copy<T>::Copy(other._ptr)) {}
  value_ptr(value_ptr && other) noexcept(noexcept(std::swap(_ptr, other._ptr)))
      : _ptr(nullptr) {
    std::swap(_ptr, other._ptr);
  }
  static value_ptr copy_of(T * const & p) {
    return detail::value_ptr_copy<T>().Copy(p);
  }

  template <typename Y> explicit operator value_ptr<Y>() const {
    return Copy(_ptr);
  }

  ~value_ptr() { delete _ptr; }

  value_ptr & operator=(value_ptr const & other) {
    swap(_ptr, value_ptr{other}._ptr);
    return *this;
  }
  value_ptr & operator=(value_ptr && other) noexcept {
    swap(_ptr, other._ptr);
    return *this;
  }

  operator bool() const noexcept { return static_cast<bool>(_ptr); }

  pointer get() const noexcept { return _ptr; }
  pointer operator->() const noexcept { return get(); }
  reference operator*() const noexcept { return *get(); }

private:
  static void swap(T * a, T * b) {
    T * tmp = a;
    a = b;
    b = tmp;
  }
  T * _ptr;
};

template <typename T, typename... Args>
value_ptr<T> make_value(Args &&... args) {
  return value_ptr<T>(new T(std::forward<Args>(args)...));
}

POINTER_TEMPLATE_COMPARE(value_ptr)