Private.hpp

//A Smart Pointer to IMPLementation (i.e. Smart PIMPL or just SPIMPL).
//********************************************************************
//Copyright (c) 2015 Andrey Upadyshev (oliora@gmail.com)
//Distributed under the Boost Software License, Version 1.0.
//See http://www.boost.org/LICENSE_1_0.txt

#pragma once

#include <memory>
#include <type_traits>
#include <cassert>

#if defined _MSC_VER && _MSC_VER < 1900  // MS Visual Studio before VS2015
#define SPIMPL_NO_CPP11_NOEXCEPT
#define SPIMPL_NO_CPP11_CONSTEXPR
#define SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
#endif

#if ! defined SPIMPL_NO_CPP11_NOEXCEPT
#define SPIMPL_NOEXCEPT noexcept
#else
#define SPIMPL_NOEXCEPT
#endif

#if ! defined SPIMPL_NO_CPP11_CONSTEXPR
#define SPIMPL_CONSTEXPR constexpr
#else
#define SPIMPL_CONSTEXPR
#endif

// define SPIMPL_HAS_AUTO_PTR to enable constructor and assignment operator that accept std::auto_ptr
// TODO: auto detect std::auto_ptr support


#ifndef PRIVATE_NS
	#define PRIVATE_NS spimpl
#endif

#ifdef PRIVATE_NS
	namespace PRIVATE_NS {
#endif
namespace details
{
template<class T>
T *default_copy(T *src)
{
	static_assert(sizeof(T) > 0, "default_copy cannot copy incomplete type");
	static_assert(!std::is_void<T>::value, "default_copy cannot copy incomplete type");
	return new T(*src);
}

template<class T>
void default_delete(T *p) SPIMPL_NOEXCEPT
{
	static_assert(sizeof(T) > 0, "default_delete cannot delete incomplete type");
	static_assert(!std::is_void<T>::value, "default_delete cannot delete incomplete type");
	delete p;
}

template<class T>
struct default_deleter
{
	using type = void(*)(T*);
};

template<class T>
using default_deleter_t = typename default_deleter<T>::type;

template<class T>
struct default_copier
{
	using type = T* (*)(T*);
};

template<class T>
using default_copier_t = typename default_copier<T>::type;

template<class T, class D, class C>
struct is_default_manageable : public std::integral_constant<bool,
	std::is_same<D, default_deleter_t<T>>::value &&
	std::is_same<C, default_copier_t<T>>::value>
{ };
}


template<class T, class Deleter = details::default_deleter_t<T>, class Copier = details::default_copier_t<T>>
class impl_ptr
{
private:
	static_assert(!std::is_array<T>::value, "impl_ptr specialization for arrays is not implemented");
	struct dummy_t_ { int dummy__; };

public:
	using pointer = T*;
	using element_type = T;
	using copier_type = typename std::decay<Copier>::type;
	using deleter_type = typename std::decay<Deleter>::type;
	using unique_ptr_type = std::unique_ptr<T, deleter_type>;
	using is_default_manageable = details::is_default_manageable<T, deleter_type, copier_type>;

	SPIMPL_CONSTEXPR impl_ptr() SPIMPL_NOEXCEPT
		: ptr_(nullptr, deleter_type{}), copier_(copier_type{}) {}

	SPIMPL_CONSTEXPR impl_ptr(std::nullptr_t) SPIMPL_NOEXCEPT
		: impl_ptr() {}

	template<class D, class C>
	impl_ptr(pointer p, D&& d, C&& c,
		typename std::enable_if<
		std::is_convertible<D, deleter_type>::value
		&& std::is_convertible<C, copier_type>::value,
		dummy_t_>::type = dummy_t_()) SPIMPL_NOEXCEPT
		: ptr_(std::move(p), std::forward<D>(d)), copier_(std::forward<C>(c)) {}

	template<class U>
	impl_ptr(U *u,
		typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& is_default_manageable::value,
		dummy_t_>::type = dummy_t_()) SPIMPL_NOEXCEPT
		: impl_ptr(u, &details::default_delete<T>, &details::default_copy<T>) {}

	impl_ptr(const impl_ptr& r)
		: impl_ptr(r.clone()) {}

	#ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
	impl_ptr(impl_ptr&& r) SPIMPL_NOEXCEPT = default;
	#else
	impl_ptr(impl_ptr&& r) SPIMPL_NOEXCEPT
		: ptr_(std::move(r.ptr_)), copier_(std::move(r.copier_)) {}
	#endif

	#ifdef SPIMPL_HAS_AUTO_PTR
	template<class U>
	impl_ptr(std::auto_ptr<U>&& u,
		typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& is_default_manageable::value,
		dummy_t_
		>::type = dummy_t_()) SPIMPL_NOEXCEPT
		: ptr_(u.release(), &details::default_delete<T>), copier_(&details::default_copy<T>) {}
	#endif

	template<class U>
	impl_ptr(std::unique_ptr<U>&& u,
		typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& is_default_manageable::value,
		dummy_t_
		>::type = dummy_t_()) SPIMPL_NOEXCEPT
		: ptr_(u.release(), &details::default_delete<T>), copier_(&details::default_copy<T>) {}

	template<class U, class D, class C>
	impl_ptr(std::unique_ptr<U, D>&& u, C&& c,
		typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& std::is_convertible<D, deleter_type>::value
		&& std::is_convertible<C, copier_type>::value,
		dummy_t_
		>::type = dummy_t_()) SPIMPL_NOEXCEPT
		: ptr_(std::move(u)), copier_(std::forward<C>(c)) {}

	template<class U, class D, class C>
	impl_ptr(impl_ptr<U, D, C>&& u,
		typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& std::is_convertible<D, deleter_type>::value
		&& std::is_convertible<C, copier_type>::value,
		dummy_t_
		>::type = dummy_t_()) SPIMPL_NOEXCEPT
		: ptr_(std::move(u.ptr_)), copier_(std::move(u.copier_)) {}

	impl_ptr& operator= (const impl_ptr& r)
	{
		if (this == &r)
			return *this;

		return operator=(r.clone());
	}

	#ifndef SPIMPL_NO_CPP11_DEFAULT_MOVE_SPEC_FUNC
	impl_ptr& operator= (impl_ptr&& r) SPIMPL_NOEXCEPT = default;
	#else
	impl_ptr& operator= (impl_ptr&& r) SPIMPL_NOEXCEPT {
		ptr_ = std::move(r.ptr_);
		copier_ = std::move(r.copier_);
		return *this;
	}
	#endif

	template<class U, class D, class C>
	typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& std::is_convertible<D, deleter_type>::value
		&& std::is_convertible<C, copier_type>::value,
		impl_ptr&
	>::type operator= (impl_ptr<U, D, C>&& u) SPIMPL_NOEXCEPT
	{
		ptr_ = std::move(u.ptr_);
		copier_ = std::move(u.copier_);
		return *this;
	}

	template<class U, class D, class C>
	typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& std::is_convertible<D, deleter_type>::value
		&& std::is_convertible<C, copier_type>::value,
		impl_ptr&
	>::type operator= (const impl_ptr<U, D, C>& u)
	{
		return operator=(u.clone());
	}

	//

	#ifdef SPIMPL_HAS_AUTO_PTR
	template<class U>
	typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& is_default_manageable::value,
		impl_ptr&
	>::type operator= (std::auto_ptr<U>&& u) SPIMPL_NOEXCEPT
	{
		return operator=(impl_ptr(std::move(u)));
	}
	#endif

	template<class U>
	typename std::enable_if<
		std::is_convertible<U*, pointer>::value
		&& is_default_manageable::value,
		impl_ptr&
	>::type operator= (std::unique_ptr<U>&& u) SPIMPL_NOEXCEPT
	{
		return operator=(impl_ptr(std::move(u)));
	}

	impl_ptr clone() const
	{
		return impl_ptr(
			ptr_ ? copier_(ptr_.get()) : nullptr,
			ptr_.get_deleter(),
			copier_);
	}

	typename std::remove_reference<T>::type & operator*() const { return *ptr_; }
	pointer operator->() const SPIMPL_NOEXCEPT { return get(); }
	pointer get() const SPIMPL_NOEXCEPT { return ptr_.get(); }

	void swap(impl_ptr& u) SPIMPL_NOEXCEPT
	{
		using std::swap;
		ptr_.swap(u.ptr_);
		swap(copier_, u.copier_);
	}

	pointer release() SPIMPL_NOEXCEPT { return ptr_.release(); }

	unique_ptr_type release_unique() SPIMPL_NOEXCEPT { return std::move(ptr_); }

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

	typename std::remove_reference<deleter_type>::type& get_deleter() SPIMPL_NOEXCEPT { return ptr_.get_deleter(); }
	const typename std::remove_reference<deleter_type>::type& get_deleter() const SPIMPL_NOEXCEPT { return ptr_.get_deleter(); }

	typename std::remove_reference<copier_type>::type& get_copier() SPIMPL_NOEXCEPT { return copier_; }
	const typename std::remove_reference<copier_type>::type& get_copier() const SPIMPL_NOEXCEPT { return copier_; }

private:
	unique_ptr_type ptr_;
	copier_type copier_;
};

template<class T, class D, class C>
inline void swap(impl_ptr<T, D, C>& l, impl_ptr<T, D, C>& r) SPIMPL_NOEXCEPT
{
	l.swap(r);
}


template <class T1, class D1, class C1, class T2, class D2, class C2>
inline bool operator==(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r)
{
	return l.get() == r.get();
}

template <class T1, class D1, class C1, class T2, class D2, class C2>
inline bool operator!=(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r)
{
	return !(l == r);
}

template <class T1, class D1, class C1, class T2, class D2, class C2>
inline bool operator< (const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r)
{
	using P1 = typename impl_ptr<T1, D1, C1>::pointer;
	using P2 = typename impl_ptr<T2, D2, C2>::pointer;
	using CT = typename std::common_type<P1, P2>::type;
	return std::less<CT>()(l.get(), r.get());
}

template <class T1, class D1, class C1, class T2, class D2, class C2>
inline bool operator> (const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r)
{
	return r < l;
}

template <class T1, class D1, class C1, class T2, class D2, class C2>
inline bool operator<=(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r)
{
	return !(r < l);
}

template <class T1, class D1, class C1, class T2, class D2, class C2>
inline bool operator>=(const impl_ptr<T1, D1, C1>& l, const impl_ptr<T2, D2, C2>& r)
{
	return !(l < r);
}

template <class T, class D, class C>
inline bool operator==(const impl_ptr<T, D, C>& p, std::nullptr_t) SPIMPL_NOEXCEPT
{
	return !p;
}

template <class T, class D, class C>
inline bool operator==(std::nullptr_t, const impl_ptr<T, D, C>& p) SPIMPL_NOEXCEPT
{
	return !p;
}

template <class T, class D, class C>
inline bool operator!=(const impl_ptr<T, D, C>& p, std::nullptr_t) SPIMPL_NOEXCEPT
{
	return static_cast<bool>(p);
}

template <class T, class D, class C>
inline bool operator!=(std::nullptr_t, const impl_ptr<T, D, C>& p) SPIMPL_NOEXCEPT
{
	return static_cast<bool>(p);
}

template <class T, class D, class C>
inline bool operator< (const impl_ptr<T, D, C>& l, std::nullptr_t)
{
	using P = typename impl_ptr<T, D, C>::pointer;
	return std::less<P>()(l.get(), nullptr);
}

template <class T, class D, class C>
inline bool operator< (std::nullptr_t, const impl_ptr<T, D, C>& p)
{
	using P = typename impl_ptr<T, D, C>::pointer;
	return std::less<P>()(nullptr, p.get());
}

template <class T, class D, class C>
inline bool operator> (const impl_ptr<T, D, C>& p, std::nullptr_t)
{
	return nullptr < p;
}

template <class T, class D, class C>
inline bool operator> (std::nullptr_t, const impl_ptr<T, D, C>& p)
{
	return p < nullptr;
}

template <class T, class D, class C>
inline bool operator<=(const impl_ptr<T, D, C>& p, std::nullptr_t)
{
	return !(nullptr < p);
}

template <class T, class D, class C>
inline bool operator<=(std::nullptr_t, const impl_ptr<T, D, C>& p)
{
	return !(p < nullptr);
}

template <class T, class D, class C>
inline bool operator>=(const impl_ptr<T, D, C>& p, std::nullptr_t)
{
	return !(p < nullptr);
}

template <class T, class D, class C>
inline bool operator>=(std::nullptr_t, const impl_ptr<T, D, C>& p)
{
	return !(nullptr < p);
}


template<class T, class... Args>
inline impl_ptr<T> make_impl(Args&&... args)
{
	return impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>, &details::default_copy<T>);
}


// Helpers to manage unique impl, stored in std::unique_ptr

template<class T, class Deleter = void(*)(T*)>
using unique_impl_ptr = std::unique_ptr<T, Deleter>;

template<class T, class... Args>
inline unique_impl_ptr<T> make_impl_nocopy(Args&&... args)
{
	static_assert(!std::is_array<T>::value, "unique_impl_ptr does not support arrays");
	return unique_impl_ptr<T>(new T(std::forward<Args>(args)...), &details::default_delete<T>);
}



#ifdef PRIVATE_NS
}
#endif


namespace std {
template <class T, class D, class C>
struct hash<
	
	#ifdef PRIVATE_NS
		PRIVATE_NS::
	#endif
	
	
	impl_ptr<T, D, C>>
{
	using argument_type = 

	#ifdef PRIVATE_NS
		PRIVATE_NS::
	#endif
		
		impl_ptr<T, D, C>;
	using result_type = size_t;

	result_type operator()(const argument_type& p) const SPIMPL_NOEXCEPT
	{
		return hash<typename argument_type::pointer>()(p.get());
	}
};
}




//********************************************************************
//********************************************************************
//********************************************************************
//********************************************************************
//Copyright (c) 2015 Aiden Koss
//Copyright (c) 2015 Open Systems International, Inc
//Distributed under the Boost Software License, Version 1.0.
//See http://www.boost.org/LICENSE_1_0.txt

#ifdef PRIVATE_NS
using namespace PRIVATE_NS;
#endif

#define ADDPRIVATE_STRUCT_COPYABLE \
private:                       \
	struct Private;            \
	friend Private;            \
	impl_ptr<Private> impl;    \
public:                        \
	static bool isCopyable() {return true;}

#define ADDPRIVATE_CLASS_COPYABLE \
private:                          \
	struct Private;               \
	friend Private;               \
	impl_ptr<Private> impl;       \
public:                           \
	static bool IsCopyable() {return true;} \
private:


#define ADDPRIVATE_STRUCT_NOCOPY   \
private:                           \
	struct Private;                \
	friend Private;                \
	unique_impl_ptr<Private> impl; \
public:                            \
	static bool IsCopyable() {return false;}

#define ADDPRIVATE_CLASS_NOCOPY    \
private:                           \
	struct Private;                \
	friend Private;                \
	unique_impl_ptr<Private> impl; \
public:                            \
	static bool IsCopyable() {return false;} \
private: