//
//  const_propogating_ptr.hpp
//  pointers
//
//  Created by Sam Jaffe on 12/3/16.
//

#pragma once
#include <memory>

#include "pointer_fwd.hpp"

template <typename T>
class const_propogating_ptr {
public:
  using element_type = typename std::pointer_traits<T>::element_type;
  using pointer = element_type  *;
  using reference = element_type &;
  using const_pointer = element_type const *;
  using const_reference = element_type const &;

  const_propogating_ptr() : _ptr(nullptr) {}
  const_propogating_ptr(T const & p) : _ptr(p) {}
  const_propogating_ptr(T && p) : _ptr(std::move(p)) {}
  
  const_propogating_ptr(const_propogating_ptr & other) : _ptr(other._ptr) {}
  const_propogating_ptr(const_propogating_ptr &&) = default;
  const_propogating_ptr(const_propogating_ptr const &) = delete;
  const_propogating_ptr& operator=(const_propogating_ptr & other) { _ptr = other._ptr; return *this; }
  const_propogating_ptr& operator=(const_propogating_ptr &&) = default;
  const_propogating_ptr& operator=(const_propogating_ptr const &) = delete;
  
  template <typename Y>
  explicit operator const_propogating_ptr<Y>() & {
    return _ptr;
  }
  
  template <typename Y>
  explicit operator const_ptr<Y>() const {
    return _ptr;
  }
  
  template <typename Y>
  explicit operator const_propogating_ptr<Y>() const & = delete;
  
  operator bool() const {
    return bool(_ptr);
  }
  
  reference operator*() { return *_ptr; }
  pointer get() { return std::addressof(operator*()); }
  pointer operator->() { return get(); }
  
  const_reference operator*() const { return *_ptr; }
  const_pointer get() const { return std::addressof(operator*()); }
  const_pointer operator->() const { return get(); }
  
private:
  T _ptr;
};

template <typename T, typename U>
bool operator==(const_propogating_ptr<T> const&lhs, const_propogating_ptr<U> const&rhs) {
  return lhs.get() == rhs.get();
}

template <typename T, typename U>
bool operator!=(const_propogating_ptr<T> const&lhs, const_propogating_ptr<U> const&rhs) {
  return !(lhs == rhs);
}

template <typename T, typename U>
bool operator< (const_propogating_ptr<T> const&lhs, const_propogating_ptr<U> const&rhs) {
  typedef typename std::common_type<
  typename const_propogating_ptr<T>::pointer,
  typename const_propogating_ptr<U>::pointer>::type V;
  return std::less<V>(lhs.get(), rhs.get());
}

template <typename T, typename U>
bool operator> (const_propogating_ptr<T> const&lhs, const_propogating_ptr<U> const&rhs) {
  return rhs < lhs;
}

template <typename T, typename U>
bool operator<=(const_propogating_ptr<T> const&lhs, const_propogating_ptr<U> const&rhs) {
  return !(rhs < lhs);
}

template <typename T, typename U>
bool operator>=(const_propogating_ptr<T> const&lhs, const_propogating_ptr<U> const&rhs) {
  return !(lhs < rhs);
}

template <typename T>
bool operator==(const_propogating_ptr<T> const&lhs, std::nullptr_t) {
  return !lhs;
}

template <typename T>
bool operator==(std::nullptr_t, const_propogating_ptr<T> const&rhs) {
  return !rhs;
}

template <typename T>
bool operator!=(const_propogating_ptr<T> const&lhs, std::nullptr_t) {
  return static_cast<bool>(lhs);
}

template <typename T>
bool operator!=(std::nullptr_t, const_propogating_ptr<T> const&rhs) {
  return static_cast<bool>(rhs);
}

template <typename T>
bool operator< (const_propogating_ptr<T> const&lhs, std::nullptr_t) {
  typedef typename const_propogating_ptr<T>::pointer V;
  return std::less<V>(lhs.get(), nullptr);
}

template <typename T>
bool operator< (std::nullptr_t, const_propogating_ptr<T> const&rhs) {
  typedef typename const_propogating_ptr<T>::pointer V;
  return std::less<V>(nullptr, rhs.get());
}

template <typename T>
bool operator> (const_propogating_ptr<T> const&lhs, std::nullptr_t) {
  return nullptr < lhs;
}

template <typename T>
bool operator> (std::nullptr_t, const_propogating_ptr<T> const&rhs) {
  return rhs < nullptr;
}

template <typename T>
bool operator<=(const_propogating_ptr<T> const&lhs, std::nullptr_t) {
  return !(nullptr < lhs);
}

template <typename T>
bool operator<=(std::nullptr_t, const_propogating_ptr<T> const&rhs) {
  return !(rhs < nullptr);
}

template <typename T>
bool operator>=(const_propogating_ptr<T> const&lhs, std::nullptr_t) {
  return !(lhs < nullptr);
}

template <typename T>
bool operator>=(std::nullptr_t, const_propogating_ptr<T> const&rhs) {
  return !(nullptr < rhs);
}