valentina/src/libs/qmuparser/make_unique.h
Roman Telezhynskyi 003c9bf33f Fix build.
2022-08-17 15:51:35 +03:00

142 lines
4.6 KiB
C++

// Implementation of C++14's make_unique for C++11 compilers.
//
// This has been tested with:
// - MSVC 11.0 (Visual Studio 2012)
// - gcc 4.6.3
// - Xcode 4.4 (with clang "4.0")
//
// It is based off an implementation proposed by Stephan T. Lavavej for
// inclusion in the C++14 standard:
// http://isocpp.org/files/papers/N3656.txt
// Where appropriate, it borrows the use of MSVC's _VARIADIC_EXPAND_0X macro
// machinery to compensate for lack of variadic templates.
//
// This file injects make_unique into the std namespace, which I acknowledge is
// technically forbidden ([C++11: 17.6.4.2.2.1/1]), but is necessary in order
// to have syntax compatibility with C++14.
//
// I perform compiler version checking for MSVC, gcc, and clang to ensure that
// we don't add make_unique if it is already there (instead, we include
// <memory> to get the compiler-provided one). You can override the compiler
// version checking by defining the symbol COMPILER_SUPPORTS_MAKE_UNIQUE.
//
//
// ===============================================================================
// This file is released into the public domain. See LICENCE for more information.
// ===============================================================================
#pragma once
// If user hasn't specified COMPILER_SUPPORTS_MAKE_UNIQUE then try to figure out
// based on compiler version if std::make_unique is provided.
#if !defined(COMPILER_SUPPORTS_MAKE_UNIQUE)
#if defined(_MSC_VER)
// std::make_unique was added in MSVC 12.0
#if _MSC_VER >= 1800 // MSVC 12.0 (Visual Studio 2013)
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#endif
#elif defined(__clang__)
// std::make_unique was added in clang 3.4, but not until Xcode 6.
// Annoyingly, Apple makes the clang version defines match the version
// of Xcode, not the version of clang.
#define CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
#if defined(__APPLE__) && CLANG_VERSION >= 60000
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#elif !defined(__APPLE__) && CLANG_VERSION >= 30400
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#endif
#elif defined(__GNUC__)
// std::make_unique was added in gcc 4.9, for standards versions greater
// than -std=c++11.
#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if GCC_VERSION >= 40900 && __cplusplus > 201103L
#define COMPILER_SUPPORTS_MAKE_UNIQUE
#endif
#endif
#endif
#if defined(COMPILER_SUPPORTS_MAKE_UNIQUE)
// If the compiler supports std::make_unique, then pull in <memory> to get it.
#include <memory>
#else
// Otherwise, the compiler doesn't provide it, so implement it ourselves.
#include <cstddef>
#include <memory>
#include <type_traits>
#include <utility>
namespace std {
template<class _Ty> struct _Unique_if {
typedef unique_ptr<_Ty> _Single_object;
};
template<class _Ty> struct _Unique_if<_Ty[]> {
typedef unique_ptr<_Ty[]> _Unknown_bound;
};
template<class _Ty, size_t N> struct _Unique_if<_Ty[N]> {
typedef void _Known_bound;
};
//
// template< class T, class... Args >
// unique_ptr<T> make_unique( Args&&... args);
//
#if defined(_MSC_VER) && (_MSC_VER < 1800)
// Macro machinery because MSVC 11.0 doesn't support variadic templates.
// The _VARIADIC_EXPAND_0X stuff is defined in <xstddef>
#define _MAKE_UNIQUE( \
TEMPLATE_LIST, PADDING_LIST, LIST, COMMA, X1, X2, X3, X4) \
template<class _Ty COMMA LIST(_CLASS_TYPE)> inline \
typename _Unique_if<_Ty>::_Single_object make_unique(LIST(_TYPE_REFREF_ARG)) \
{ \
return unique_ptr<_Ty>(new _Ty(LIST(_FORWARD_ARG))); \
} \
_VARIADIC_EXPAND_0X(_MAKE_UNIQUE, , , , )
#undef _MAKE_UNIQUE
#else // not MSVC 11.0 or earlier
template<class _Ty, class... Args>
typename _Unique_if<_Ty>::_Single_object
make_unique(Args&&... args) {
return unique_ptr<_Ty>(new _Ty(std::forward<Args>(args)...));
}
#endif
// template< class T >
// unique_ptr<T> make_unique( std::size_t size );
template<class _Ty>
typename _Unique_if<_Ty>::_Unknown_bound
make_unique(size_t n) {
typedef typename remove_extent<_Ty>::type U;
return unique_ptr<_Ty>(new U[n]());
}
// template< class T, class... Args >
// /* unspecified */ make_unique( Args&&... args ) = delete;
// MSVC 11.0 doesn't support deleted functions, so the best we can do
// is simply not define the function.
#if !(defined(_MSC_VER) && (_MSC_VER < 1800))
template<class T, class... Args>
typename _Unique_if<T>::_Known_bound
make_unique(Args&&...) = delete;
#endif
} // namespace std
#endif // !COMPILER_SUPPORTS_MAKE_UNIQUE