cloneable_ptr.hh

Go to the documentation of this file.

#ifndef CASM_cloneable_ptr_HH
#define CASM_cloneable_ptr_HH
 
#include <iostream>
#include <memory>
#include <utility>
 
#include "casm/misc/type_traits.hh"
 
#define ABSTRACT_CLONEABLE(T)                                             \
 public:                                                                  \
  virtual ~T() {}                                                         \
                                                                          \
  std::unique_ptr<T> clone() const {                                      \
    return std::unique_ptr<T>(this->_clone());                            \
  }                                                                       \
  std::unique_ptr<T> move() { return std::unique_ptr<T>(this->_move()); } \
                                                                          \
 private:                                                                 \
  virtual T *_clone() const = 0;                                          \
  virtual T *_move() = 0;                                                 \
                                                                          \
 public:
 
#define ABSTRACT_CLONEABLE_DERIVED(T)                                     \
 public:                                                                  \
  virtual ~T() {}                                                         \
                                                                          \
  std::unique_ptr<T> clone() const {                                      \
    return std::unique_ptr<T>(this->_clone());                            \
  }                                                                       \
  std::unique_ptr<T> move() { return std::unique_ptr<T>(this->_move()); } \
                                                                          \
 private:                                                                 \
  virtual T *_clone() const override = 0;                                 \
  virtual T *_move() override = 0;                                        \
                                                                          \
 public:
 
#define CLONEABLE(T)                                                      \
 public:                                                                  \
  virtual ~T() {}                                                         \
                                                                          \
  std::unique_ptr<T> clone() const {                                      \
    return std::unique_ptr<T>(this->_clone());                            \
  }                                                                       \
  std::unique_ptr<T> move() { return std::unique_ptr<T>(this->_move()); } \
                                                                          \
 private:                                                                 \
  virtual T *_clone() const override { return new T(*this); }             \
  virtual T *_move() override { return new T(std::move(*this)); }         \
                                                                          \
 public:
 
#define CLONEABLE_NEEDS_DESTRUCTOR_DEF(T)                                 \
 public:                                                                  \
  virtual ~T();                                                           \
                                                                          \
  std::unique_ptr<T> clone() const {                                      \
    return std::unique_ptr<T>(this->_clone());                            \
  }                                                                       \
  std::unique_ptr<T> move() { return std::unique_ptr<T>(this->_move()); } \
                                                                          \
 private:                                                                 \
  virtual T *_clone() const override { return new T(*this); }             \
  virtual T *_move() override { return new T(std::move(*this)); }         \
                                                                          \
 public:
 
namespace notstd {
 
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
 
class Cloneable {
 public:
  virtual ~Cloneable() {}
 
  std::unique_ptr<Cloneable> clone() const {
    return std::unique_ptr<Cloneable>(this->_clone());
  }
  std::unique_ptr<Cloneable> move() {
    return std::unique_ptr<Cloneable>(this->_move());
  }
 
 private:
  virtual Cloneable *_clone() const = 0;
  virtual Cloneable *_move() = 0;
};
 
template <typename Type>
class cloneable_ptr;
 
template <typename T, typename... Args>
cloneable_ptr<T> make_cloneable(Args &&... args) {
  return cloneable_ptr<T>(new T(std::forward<Args>(args)...));
}
 
template <typename T, typename = void>
struct has_clone : std::false_type {};
 
template <typename T>
struct has_clone<T, void_t<decltype(&T::clone)> > : std::true_type {};
 
template <typename T,
          typename std::enable_if<!has_clone<T>::value, void>::type * = nullptr>
std::unique_ptr<T> clone(const T &obj);
 
template <typename T,
          typename std::enable_if<has_clone<T>::value, void>::type * = nullptr>
std::unique_ptr<T> clone(const T &obj);
 
template <typename T, typename = void>
struct has_move : std::false_type {};
 
template <typename T>
struct has_move<T, void_t<decltype(&T::move)> > : std::true_type {};
 
template <typename T,
          typename std::enable_if<!has_move<T>::value, void>::type * = nullptr>
std::unique_ptr<T> clone_move(T &&obj);
 
template <typename T,
          typename std::enable_if<has_move<T>::value, void>::type * = nullptr>
std::unique_ptr<T> clone_move(T &&obj);
 
template <typename Type>
class cloneable_ptr {
 public:
  typedef Type element_type;
  typedef Type *pointer;
  typedef Type &reference;
 
  cloneable_ptr() {}
 
  explicit cloneable_ptr(pointer ptr);
 
  cloneable_ptr(const cloneable_ptr &other);
 
  template <typename U>
  cloneable_ptr(const cloneable_ptr<U> &other);
 
  cloneable_ptr(cloneable_ptr &&other);
 
  template <typename U>
  cloneable_ptr(cloneable_ptr<U> &&other);
 
  template <typename U>
  cloneable_ptr(const std::unique_ptr<U> &other);
 
  template <typename U>
  cloneable_ptr(std::unique_ptr<U> &&other);
 
  ~cloneable_ptr();
 
  cloneable_ptr &operator=(cloneable_ptr other);
 
  template <typename U>
  cloneable_ptr &operator=(cloneable_ptr<U> &&other);
 
  template <typename U>
  cloneable_ptr &operator=(const std::unique_ptr<U> &other);
 
  template <typename U>
  cloneable_ptr &operator=(std::unique_ptr<U> &&other);
 
  reference operator*() const;
 
  pointer operator->() const;
 
  void reset();
 
  std::unique_ptr<Type> &unique();
 
  const std::unique_ptr<Type> &unique() const;
 
  explicit operator bool() const;
 
 private:
  std::unique_ptr<Type> m_unique;
};
 
template <typename Type>
void swap(cloneable_ptr<Type> &A, cloneable_ptr<Type> &B);
 
template <typename Type>
bool operator<(const cloneable_ptr<Type> &A, const cloneable_ptr<Type> &B);
 
template <typename Type>
bool operator==(const cloneable_ptr<Type> &A, const cloneable_ptr<Type> &B);
 
template <typename Type>
bool operator!=(const cloneable_ptr<Type> &A, const cloneable_ptr<Type> &B);
 
template <typename Type>
bool operator==(std::nullptr_t, const cloneable_ptr<Type> &B);
 
template <typename Type>
bool operator!=(std::nullptr_t, const cloneable_ptr<Type> &B);
 
template <typename Type>
bool operator==(const cloneable_ptr<Type> &A, std::nullptr_t);
 
template <typename Type>
bool operator!=(const cloneable_ptr<Type> &A, std::nullptr_t);
 
// --- Immplementation ---
 
template <typename T,
          typename std::enable_if<!has_clone<T>::value, void>::type *>
std::unique_ptr<T> clone(const T &obj) {
  return std::unique_ptr<T>(new T(obj));
}
 
template <typename T,
          typename std::enable_if<has_clone<T>::value, void>::type *>
std::unique_ptr<T> clone(const T &obj) {
  return obj.clone();
}
 
template <typename T,
          typename std::enable_if<!has_move<T>::value, void>::type *>
std::unique_ptr<T> clone_move(T &&obj) {
  return clone(std::move(obj));
}
 
template <typename T, typename std::enable_if<has_move<T>::value, void>::type *>
std::unique_ptr<T> clone_move(T &&obj) {
  return obj.move();
}
 
template <typename Type>
cloneable_ptr<Type>::cloneable_ptr(pointer ptr) : m_unique(ptr) {}
 
template <typename Type>
cloneable_ptr<Type>::cloneable_ptr(const cloneable_ptr &other) : m_unique() {
  if (other) {
    m_unique = std::move(clone(*other));
  }
}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type>::cloneable_ptr(const cloneable_ptr<U> &other) : m_unique() {
  if (other) {
    m_unique = std::move(clone(*other));
  }
}
 
template <typename Type>
cloneable_ptr<Type>::cloneable_ptr(cloneable_ptr &&other)
    : m_unique(std::move(other.unique())) {}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type>::cloneable_ptr(cloneable_ptr<U> &&other)
    : m_unique(std::move(other.unique())) {}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type>::cloneable_ptr(const std::unique_ptr<U> &other)
    : m_unique() {
  if (other) {
    m_unique = std::move(clone(*other));
  }
}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type>::cloneable_ptr(std::unique_ptr<U> &&other)
    : m_unique(std::move(other)) {}
 
template <typename Type>
cloneable_ptr<Type>::~cloneable_ptr() {}
 
template <typename Type>
cloneable_ptr<Type> &cloneable_ptr<Type>::operator=(cloneable_ptr other) {
  swap(*this, other);
  return *this;
}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type> &cloneable_ptr<Type>::operator=(cloneable_ptr<U> &&other) {
  unique() = std::move(other.unique());
  return *this;
}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type> &cloneable_ptr<Type>::operator=(
    const std::unique_ptr<U> &other) {
  if (other) {
    unique() = clone(*other);
  } else {
    unique().reset();
  }
  return *this;
}
 
template <typename Type>
template <typename U>
cloneable_ptr<Type> &cloneable_ptr<Type>::operator=(
    std::unique_ptr<U> &&other) {
  unique() = std::move(other);
  return *this;
}
 
template <typename Type>
typename cloneable_ptr<Type>::reference cloneable_ptr<Type>::operator*() const {
  return *m_unique;
}
 
template <typename Type>
typename cloneable_ptr<Type>::pointer cloneable_ptr<Type>::operator->() const {
  return &(this->operator*());
}
 
template <typename Type>
void cloneable_ptr<Type>::reset() {
  return m_unique.reset();
}
 
template <typename Type>
std::unique_ptr<Type> &cloneable_ptr<Type>::unique() {
  return m_unique;
}
 
template <typename Type>
const std::unique_ptr<Type> &cloneable_ptr<Type>::unique() const {
  return m_unique;
}
 
template <typename Type>
cloneable_ptr<Type>::operator bool() const {
  return static_cast<bool>(m_unique);
}
 
template <typename Type>
void swap(cloneable_ptr<Type> &A, cloneable_ptr<Type> &B) {
  A.unique().swap(B.unique());
}
 
template <typename Type>
bool operator<(const cloneable_ptr<Type> &A, const cloneable_ptr<Type> &B) {
  return A.unique() < B.unique();
}
 
template <typename Type>
bool operator==(const cloneable_ptr<Type> &A, const cloneable_ptr<Type> &B) {
  return A.unique() == B.unique();
}
 
template <typename Type>
bool operator!=(const cloneable_ptr<Type> &A, const cloneable_ptr<Type> &B) {
  return A.unique() != B.unique();
}
 
template <typename Type>
bool operator==(std::nullptr_t, const cloneable_ptr<Type> &B) {
  return B.unique() == nullptr;
}
 
template <typename Type>
bool operator!=(std::nullptr_t, const cloneable_ptr<Type> &B) {
  return B.unique() != nullptr;
}
 
template <typename Type>
bool operator==(const cloneable_ptr<Type> &A, std::nullptr_t) {
  return A.unique() == nullptr;
}
 
template <typename Type>
bool operator!=(const cloneable_ptr<Type> &A, std::nullptr_t) {
  return A.unique() != nullptr;
}
 
}  // namespace notstd
 
#endif