cloneable_ptr.hh

Go to the documentation of this file.

#ifndef CASM_cloneable_ptr_HH
#define CASM_cloneable_ptr_HH

#include <memory>
#include <iostream>

#include "casm/misc/CASM_TMP.hh"

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:
    std::unique_ptr<Cloneable> clone() const {
      return std::unique_ptr<Cloneable>(this->_clone());
    }
  private:
    virtual Cloneable *_clone() const = 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, CASM::CASM_TMP::void_t<decltype(std::declval<T &>().clone())> > : std::true_type { };


  template<typename T>
  std::unique_ptr<T> clone(const T &obj, typename std::enable_if<has_clone<T>::value, T>::type * = nullptr) {
    return obj.clone();
  }

  template<typename T>
  std::unique_ptr<T> clone(const T &obj, typename std::enable_if < !has_clone<T>::value, T >::type * = nullptr) {
    return std::unique_ptr<T>(new 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) :
      m_unique(ptr) {}

    explicit cloneable_ptr(const Type &obj) :
      m_unique(clone(obj)) {}


    cloneable_ptr(const cloneable_ptr &other) :
      m_unique() {
      if(other) {
        m_unique = std::move(clone(*other));
      }
    }

    template<typename U>
    cloneable_ptr(const cloneable_ptr<U> &other) :
      m_unique() {
      if(other) {
        m_unique = std::move(clone(*other));
      }
    }

    template<typename U>
    cloneable_ptr(cloneable_ptr<U> &&other) :
      m_unique(std::move(other.unique())) {}


    template<typename U>
    cloneable_ptr(const std::unique_ptr<U> &other) :
      m_unique() {
      if(other) {
        m_unique = std::move(clone(*other));
      }
    }

    template<typename U>
    cloneable_ptr(std::unique_ptr<U> &&other) :
      m_unique(std::move(other)) {}


    cloneable_ptr &operator=(cloneable_ptr other) {
      swap(*this, other);
      return *this;
    }

    template<typename U>
    cloneable_ptr &operator=(cloneable_ptr<U> && other) {
      unique() = std::move(other.unique());
      return *this;
    }


    template<typename U>
    cloneable_ptr &operator=(const std::unique_ptr<U> &other) {
      if(other) {
        unique() = clone(*other);
      }
      else {
        unique().reset();
      }
      return *this;
    }

    template<typename U>
    cloneable_ptr &operator=(std::unique_ptr<U> && other) {
      unique() = std::move(other);
      return *this;
    }


    reference operator*() const {
      return *m_unique;
    }

    pointer operator->() const {
      return &(this->operator*());
    }

    void reset() {
      return m_unique.reset();
    }

    std::unique_ptr<Type> &unique() {
      return m_unique;
    }

    const std::unique_ptr<Type> &unique() const {
      return m_unique;
    }

    explicit operator bool() const {
      return static_cast<bool>(m_unique);
    }

  private:

    std::unique_ptr<Type> 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();
  }
}

#endif