copyableuniqueptr.h

#ifndef CTL_COPYABLEUNIQUEPTR_H
#define CTL_COPYABLEUNIQUEPTR_H

#include <memory>

namespace CTL {

template <class T>
class CopyableUniquePtr : private std::unique_ptr<T>
{
public:
    // ctors
    CopyableUniquePtr() = default;
    CopyableUniquePtr(std::unique_ptr<T> uniquePtr) noexcept;
    using std::unique_ptr<T>::unique_ptr;
    // copy
    CopyableUniquePtr(const CopyableUniquePtr<T>& other);
    CopyableUniquePtr& operator=(const CopyableUniquePtr<T>& other);
    // move
    CopyableUniquePtr(CopyableUniquePtr<T>&& other) = default;
    CopyableUniquePtr& operator=(CopyableUniquePtr<T>&& other) = default;
    // dtor
    ~CopyableUniquePtr() = default;

    // public access to `std::unique_ptr<T>` interface
    using std::unique_ptr<T>::get;
    using std::unique_ptr<T>::get_deleter;
    using std::unique_ptr<T>::release;
    using std::unique_ptr<T>::reset;
    using std::unique_ptr<T>::swap;
    using std::unique_ptr<T>::operator bool;
    using std::unique_ptr<T>::operator->;
    using std::unique_ptr<T>::operator*;

    // convenience methods
    bool isNull() const noexcept;
    std::unique_ptr<T>& wrapped() noexcept;
    const std::unique_ptr<T>& wrapped() const noexcept;
};

template <class T>
CopyableUniquePtr<T>::CopyableUniquePtr(std::unique_ptr<T> uniquePtr) noexcept
    : std::unique_ptr<T>(std::move(uniquePtr))
{
}

template <class T>
CopyableUniquePtr<T>::CopyableUniquePtr(const CopyableUniquePtr<T>& other)
    : std::unique_ptr<T>(other ? static_cast<T*>(other->clone()) : nullptr)
{
}

template <class T>
CopyableUniquePtr<T>& CopyableUniquePtr<T>::operator=(const CopyableUniquePtr<T>& other)
{
    this->reset(other ? static_cast<T*>(other->clone()) : nullptr);
    return *this;
}

template <class T>
bool CopyableUniquePtr<T>::isNull() const noexcept
{
    return *this == nullptr;
}

template <class T>
std::unique_ptr<T>& CopyableUniquePtr<T>::wrapped() noexcept
{
    return *this;
}

template <class T>
const std::unique_ptr<T>& CopyableUniquePtr<T>::wrapped() const noexcept
{
    return *this;
}

} // namespace CTL

#endif // CTL_COPYABLEUNIQUEPTR_H