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

//
//  const_ptr.hpp
//  pointers
//
//  Created by Sam Jaffe on 1/5/17.
//

#pragma once
#include <memory>

#include "detail/compare.hpp"
#include "detail/get_ptr.hpp"
#include "pointer_fwd.hpp"

template <typename P>
class const_ptr : private detail::get_ptr<P>,
                  public detail::pointer_compare<const_ptr<P>> {
public:
  using element_type = typename std::pointer_traits<P>::element_type;
  using pointer = element_type const *;
  using reference = element_type const &;

  const_ptr() noexcept : _ptr(nullptr) {}
  const_ptr(P const & p) noexcept(std::is_nothrow_copy_constructible<P>::value)
      : _ptr(p) {}
  const_ptr(P && p) noexcept(std::is_nothrow_move_constructible<P>::value)
      : _ptr(std::move(p)) {}
  template <typename Y, typename = typename std::enable_if<
                            std::is_constructible<P, Y>::value>::type>
  const_ptr(Y const & p) : _ptr(p) {}
  template <typename Y, typename = typename std::enable_if<
                            std::is_constructible<P, Y>::value>::type>
  const_ptr(Y && p) : _ptr(std::forward<Y>(p)) {}

  template <typename Y>
  explicit operator const_ptr<Y>() const
      noexcept(std::is_nothrow_constructible<P, Y>::value) {
    return _ptr;
  }

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

  reference operator*() const noexcept(noexcept(*_ptr)) { return *_ptr; }
  pointer get() const noexcept(noexcept(detail::get_ptr<P>::get(_ptr))) {
    return detail::get_ptr<P>::get(_ptr);
  }
  pointer operator->() const noexcept(noexcept(get())) { return get(); }

private:
  P _ptr;
};