recursive_wrapper.hpp

Go to the documentation of this file.

#if !defined(RECURSIVE_WRAPPER_77D62153_38D6_4311_8B5C_384D740BDF6E_H)
#  define RECURSIVE_WRAPPER_77D62153_38D6_4311_8B5C_384D740BDF6E_H


#include <pgs/type_traits.hpp>

#include <utility> // std::forward<>()

namespace pgs {

template <class T>
class recursive_wrapper; //fwd. decl.

template <class T> 
struct is_recursive_wrapper : std::false_type 
{};

template <class T> 
struct is_recursive_wrapper<recursive_wrapper<T>> : std::true_type 
{};

template <class T>
using not_is_a_recursive_wrapper = negation<is_recursive_wrapper<T>>;
  
//
template <class T>
struct recursive_wrapper_unwrap {
  typedef T type; 
};

template <class T>
struct recursive_wrapper_unwrap<recursive_wrapper<T>> {
  typedef T type; 
};

template <class W>
using recursive_wrapper_unwrap_t = 
  typename recursive_wrapper_unwrap<W>::type;

template <class T, class U>
using is_recursive_wrapper_containing =
  and_<
      is_recursive_wrapper<T>
    , std::is_same<U, recursive_wrapper_unwrap_t<T>>
  >;

template <class T, class U>
using not_is_recursive_wrapper_containing =
  negation<is_recursive_wrapper_containing<T, U>>;

template <class T>
class recursive_wrapper {
private:
  T* p_;

private:  
  recursive_wrapper& assign (T const& rhs);

public:
  typedef T type;   

public:

  template <class... Args> recursive_wrapper (Args&&... args);
  recursive_wrapper (recursive_wrapper const& rhs);
  recursive_wrapper (type const& rhs);
  recursive_wrapper(recursive_wrapper&& rhs);
  recursive_wrapper(type&& rhs);
  ~recursive_wrapper();

  recursive_wrapper& operator=(recursive_wrapper const& rhs);
  recursive_wrapper& operator=(type const& rhs);
  recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept;
  recursive_wrapper& operator=(type&& rhs);

  void swap(recursive_wrapper& rhs) noexcept;

  type& get(); 
  type const& get() const; 
  type* get_pointer(); 
  type const* get_pointer() const; 
};

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

template <class T>
bool operator!= (
  recursive_wrapper<T> const& lhs, recursive_wrapper<T> const& rhs) {
  return !(lhs.get () == rhs.get ());
}

}//namespace pgs

namespace pgs {

template<class T>
  template <class... Args> 
recursive_wrapper<T>::recursive_wrapper (Args&&... args) : 
    p_(new T (std::forward<Args>(args)...)) {
}

template<class T>
recursive_wrapper<T>::recursive_wrapper (recursive_wrapper const& rhs) : 
    p_ (new T (rhs.get ())) {
}

template<class T>
recursive_wrapper<T>::recursive_wrapper (T const& rhs) : p_ (new T (rhs)) {
}

template<class T>
recursive_wrapper<T>::recursive_wrapper(recursive_wrapper&& rhs) : 
    p_ (new T (std::move (rhs.get ()))) {
}

template <class T>
recursive_wrapper<T>::recursive_wrapper(T&& rhs) : p_ (new T (std::move (rhs))) {
}

template <class T>
recursive_wrapper<T>::~recursive_wrapper() {
  delete p_; 
}

template <class T>
recursive_wrapper<T>& 
  recursive_wrapper<T>::operator=(recursive_wrapper const& rhs){ 
  return assign (rhs.get()); 
}

template <class T>
recursive_wrapper<T>& recursive_wrapper<T>::operator=(T const& rhs) { 
  return assign (rhs); 
}

template <class T>
recursive_wrapper<T>& recursive_wrapper<T>::assign (T const& rhs) { 
  this->get() = rhs; return *this; 
}

template <class T>
void recursive_wrapper<T>::swap(recursive_wrapper& rhs) noexcept { 
  std::swap (p_, rhs.p_); 
}

template <class T>
recursive_wrapper<T>&
recursive_wrapper<T>::operator=(recursive_wrapper&& rhs) noexcept { 
  swap (rhs); 
  return *this; 
}

template <class T>
recursive_wrapper<T>&
recursive_wrapper<T>::operator=(T&& rhs) { 
  get() = std::move (rhs); 
  return *this; 
}

template <typename T>
inline void swap(
  recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept {
  lhs.swap(rhs);
}

template <typename T>
T& recursive_wrapper<T>::get() { return *get_pointer(); }

template <typename T>
T const& recursive_wrapper<T>::get() const { return *get_pointer(); }

template <typename T>
T* recursive_wrapper<T>::get_pointer() { return p_; }

template <typename T>
T const* recursive_wrapper<T>::get_pointer() const { return p_; }

}//namespace pgs


#endif