ObserverPtr.h

Go to the documentation of this file.

/*
 * ObserverPtr.h
 *
 *  Created on: 09 Aug 2017
 *      Author: Nicola Mori
 */

#ifndef OBSERVERPTR_H_
#define OBSERVERPTR_H_

#include <core/Traits.h>

#include <iostream>
#include <memory>
#include <stdexcept>
#include <type_traits>
namespace EA {

template <typename T> class observer_ptr {
public:
  /* ********* Constructors and assignment operators ********* */

  observer_ptr() : _ptr(nullptr) {}

  observer_ptr(std::nullptr_t) { _ptr = nullptr; }

  template <typename W> observer_ptr(const observer_ptr<W> p) { _ptr = p.get(); }

  template <typename W> observer_ptr &operator=(const observer_ptr<W> &p) {
    _ptr = p.get();
    return *this;
  }

  /* ********* Constructors and assignment operators from raw pointers ********* */

  template <typename W> observer_ptr(W *p) { _ptr = p; }

  template <typename W> observer_ptr &operator=(W *p) {
    _ptr = p;
    return *this;
  }

  /* ********* Construction and assignment from other types of smart pointer ********* */

  template <typename W> observer_ptr(const std::unique_ptr<W> &p) { _ptr = p.get(); }

  template <typename W> observer_ptr &operator=(const std::unique_ptr<W> &p) {
    _ptr = p.get();
    return *this;
  }

  template <typename W> observer_ptr(const std::shared_ptr<W> p) { _ptr = p.get(); }

  template <typename W> observer_ptr &operator=(const std::shared_ptr<W> &p) {
    _ptr = p.get();
    return *this;
  }

  /* ********* Conversion methods ********* */

  operator bool() const { return _ptr != nullptr; }

  operator int() const = delete;

  template <typename W> operator W *() { return _ptr; }

  /* ********* Data access methods ********* */

  T *get() const { return _ptr; }

  T *operator->() const { return _ptr; }

  T &operator*() const {
    if (_ptr == nullptr)
      throw(std::runtime_error("observer_ptr points to nothing"));
    return *_ptr;
  }

  /* ********* Comparison operators ********* */
  //  /*! @brief Comparison with observer_ptr.
  //   *
  //   * The template argument type W must either exactly match the type T or be a child class of T.
  //   *
  //   * @param p The lhs observer_ptr.
  //   * @return true if lhs and rhs point to the same address.
  //   */
  //  //  template <typename W> bool operator==(const observer_ptr<typename std::decay<W>::type> &p) {
  //  //    std::cout << "1: " << _ptr << "  " << p.get() << std::endl;
  //  //    return (_ptr == p._ptr);
  //  //  }
  //
  //  /*! @brief Comparison with raw pointer.
  //   *
  //   * The template argument type W must either exactly match the type T or be a child class of T.
  //   *
  //   * @param p The lhs observer_ptr.
  //   * @return true if lhs and rhs point to the same address.
  //   */
  //  template <typename W> bool operator==(typename std::decay<W>::type *p) {
  //    std::cout << "2: " << _ptr << "  " << p << std::endl;
  //    return (_ptr == p);
  //  }
  //
  //  /*! @brief Comparison with std::unique_ptr.
  //   *
  //   * The template argument type W must either exactly match the type T or be a child class of T.
  //   *
  //   * @param p The lhs std::unique_ptr.
  //   * @return true if lhs and rhs point to the same address.
  //   */
  //  template <typename W> bool operator==(const std::unique_ptr<typename std::decay<W>::type> &p) {
  //    std::cout << "3: " << _ptr << "  " << p.get() << std::endl;
  //    return (_ptr == p.get());
  //  }
  //
  //  /*! @brief Comparison with std::shared_ptr.
  //   *
  //   * The template argument type W must either exactly match the type T or be a child class of T.
  //   *
  //   * @param p The lhs std::shared_ptr.
  //   * @return true if lhs and rhs point to the same address.
  //   */
  //  template <typename W> bool operator==(const std::shared_ptr<typename std::decay<W>::type> &p) {
  //    std::cout << "4: " << _ptr << "  " << p.get() << std::endl;
  //    return (_ptr == p.get());
  //  }

  //  template <typename W> bool operator!=(const observer_ptr<typename std::decay<W>::type> &p) {
  //    std::cout << "!1: " << _ptr << "  " << p.get() << std::endl;
  //    return !(_ptr == p.get());
  //  }
  //  template <typename W> bool operator!=(typename std::decay<W>::type *p) {
  //    std::cout << "!2: " << _ptr << "  " << p << std::endl;
  //    return !(_ptr == p);
  //  }
  //  template <typename W> bool operator!=(const std::unique_ptr<typename std::decay<W>::type> &p) {
  //    std::cout << "!3: " << _ptr << "  " << p.get() << std::endl;
  //    return !(_ptr == p.get());
  //  }
  //  template <typename W> bool operator!=(const std::shared_ptr<typename std::decay<W>::type> &p) {
  //    std::cout << "!4: " << _ptr << "  " << p.get() << std::endl;
  //    return !(_ptr == p.get());
  //  }

private:
  T *_ptr;
};

// Some useful metaprogramming tools:
// 1. Check if the template type is observer_ptr
template <typename T> struct is_observer_ptr : std::false_type {};
template <typename T> struct is_observer_ptr<observer_ptr<T>> : std::true_type {};
// 2. Check if at least one type is observer_ptr
template <typename T, typename W> struct one_observer_ptr : or_<is_observer_ptr<T>, is_observer_ptr<W>> {};
// 3. Check if at least one type is observer_ptr and the other one is not a pointer
template <typename T, typename W>
struct one_observer_ptr_and_no_pointer : and_<                                                 //
                                             or_<is_observer_ptr<T>, is_observer_ptr<W>>,      //
                                             not_<                                             //
                                                 and_<std::is_pointer<T>, std::is_pointer<W>>> //
                                             > {};

// Comparison operators
// Overloads for one pointer argument
template <typename T, typename W>
typename std::enable_if_t<std::is_pointer<W>::value, bool> operator==(const observer_ptr<T> &p1, const W &p2) {
  return (p1.get() == p2);
}

template <typename T, typename W>
typename std::enable_if_t<std::is_pointer<W>::value, bool> operator==(const W &p1, const observer_ptr<T> &p2) {
  return (p2 == p1);
}

// Overloads for one observer_ptr and no pointers (i.e. the other argument must be a smart pointer which implements
// get())
template <typename T, typename W>
typename std::enable_if_t<one_observer_ptr_and_no_pointer<T, W>::value, bool> operator==(const T &p1, const W &p2) {
  return (p1.get() == p2.get());
}

template <typename T, typename W>
typename std::enable_if_t<one_observer_ptr<T, W>::value, bool> operator!=(const T &p1, const W &p2) {
  return !(p1 == p2);
}

} // namespace EA

#endif /* OBSERVERPTR_H_ */