tqcq/ulib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat support ulib::any
All checks were successful
rpcrypto-build / build (Debug, hisiv510.toolchain.cmake) (push) Successful in 1m1s
Details
rpcrypto-build / build (Release, himix200.toolchain.cmake) (push) Successful in 1m42s
Details
linux-x64-gcc / linux-gcc (push) Successful in 1m47s
Details
rpcrypto-build / build (Debug, himix200.toolchain.cmake) (push) Successful in 1m59s
Details
linux-hisiv500-gcc / linux-gcc-hisiv500 (push) Successful in 1m56s
Details
rpcrypto-build / build (Release, hisiv510.toolchain.cmake) (push) Successful in 2m2s
Details
linux-mips64-gcc / linux-gcc-mips64el (push) Successful in 3m16s
Details

Browse Source
This commit is contained in:
tqcq 2024-01-06 13:56:12 +08:00
parent 1e40424caf
commit bb4d3c68be
1 changed files with 341 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

583
3party/nonstd/any.h
View File

@ -15,10 +15,12 @@
#define any_lite_MINOR 4
#define any_lite_PATCH 0
#define any_lite_VERSION any_STRINGIFY(any_lite_MAJOR) "." any_STRINGIFY(any_lite_MINOR) "." any_STRINGIFY(any_lite_PATCH)
#define any_lite_VERSION \
any_STRINGIFY(any_lite_MAJOR) "." any_STRINGIFY( \
any_lite_MINOR) "." any_STRINGIFY(any_lite_PATCH)
#define any_STRINGIFY( x ) any_STRINGIFY_( x )
#define any_STRINGIFY_( x ) #x
#define any_STRINGIFY(x) any_STRINGIFY_(x)
#define any_STRINGIFY_(x) #x
// any-lite configuration:
@ -29,9 +31,9 @@
// tweak header support:
#ifdef __has_include
# if __has_include(<nonstd/any.tweak.hpp>)
# include <nonstd/any.tweak.hpp>
# endif
#if __has_include(<nonstd/any.tweak.hpp>)
#include <nonstd/any.tweak.hpp>
#endif
#define any_HAVE_TWEAK_HEADER 1
#else
#define any_HAVE_TWEAK_HEADER 0
@ -40,54 +42,56 @@
// any selection and configuration:
#if !defined( any_CONFIG_SELECT_ANY )
# define any_CONFIG_SELECT_ANY ( any_HAVE_STD_ANY ? any_ANY_STD : any_ANY_NONSTD )
#if !defined(any_CONFIG_SELECT_ANY)
#define any_CONFIG_SELECT_ANY (any_HAVE_STD_ANY ? any_ANY_STD : any_ANY_NONSTD)
#endif
// Control presence of exception handling (try and auto discover):
#ifndef any_CONFIG_NO_EXCEPTIONS
# if defined(_MSC_VER)
# include <cstddef> // for _HAS_EXCEPTIONS
# endif
# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
# define any_CONFIG_NO_EXCEPTIONS 0
# else
# define any_CONFIG_NO_EXCEPTIONS 1
# endif
#if defined(_MSC_VER)
#include <cstddef>// for _HAS_EXCEPTIONS
#endif
#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
#define any_CONFIG_NO_EXCEPTIONS 0
#else
#define any_CONFIG_NO_EXCEPTIONS 1
#endif
#endif
// C++ language version detection (C++23 is speculative):
// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
#ifndef any_CPLUSPLUS
# if defined(_MSVC_LANG ) && !defined(__clang__)
# define any_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
# else
# define any_CPLUSPLUS __cplusplus
# endif
#if defined(_MSVC_LANG) && !defined(__clang__)
#define any_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
#else
#define any_CPLUSPLUS __cplusplus
#endif
#endif
#define any_CPP98_OR_GREATER ( any_CPLUSPLUS >= 199711L )
#define any_CPP11_OR_GREATER ( any_CPLUSPLUS >= 201103L )
#define any_CPP14_OR_GREATER ( any_CPLUSPLUS >= 201402L )
#define any_CPP17_OR_GREATER ( any_CPLUSPLUS >= 201703L )
#define any_CPP20_OR_GREATER ( any_CPLUSPLUS >= 202002L )
#define any_CPP23_OR_GREATER ( any_CPLUSPLUS >= 202300L )
#define any_CPP98_OR_GREATER (any_CPLUSPLUS >= 199711L)
#define any_CPP11_OR_GREATER (any_CPLUSPLUS >= 201103L)
#define any_CPP14_OR_GREATER (any_CPLUSPLUS >= 201402L)
#define any_CPP17_OR_GREATER (any_CPLUSPLUS >= 201703L)
#define any_CPP20_OR_GREATER (any_CPLUSPLUS >= 202002L)
#define any_CPP23_OR_GREATER (any_CPLUSPLUS >= 202300L)
// Use C++17 std::any if available and requested:
#if any_CPP17_OR_GREATER && defined(__has_include )
# if __has_include( <any> )
# define any_HAVE_STD_ANY 1
# else
# define any_HAVE_STD_ANY 0
# endif
#if any_CPP17_OR_GREATER && defined(__has_include)
#if __has_include(<any> )
#define any_HAVE_STD_ANY 1
#else
# define any_HAVE_STD_ANY 0
#define any_HAVE_STD_ANY 0
#endif
#else
#define any_HAVE_STD_ANY 0
#endif
#define any_USES_STD_ANY ( (any_CONFIG_SELECT_ANY == any_ANY_STD) || ((any_CONFIG_SELECT_ANY == any_ANY_DEFAULT) && any_HAVE_STD_ANY) )
#define any_USES_STD_ANY \
((any_CONFIG_SELECT_ANY == any_ANY_STD) \
|| ((any_CONFIG_SELECT_ANY == any_ANY_DEFAULT) && any_HAVE_STD_ANY))
//
// in_place: code duplicated in any-lite, expected-lite, optional-lite, value-ptr-lite, variant-lite:
@ -105,77 +109,87 @@
namespace nonstd {
using std::in_place;
using std::in_place_type;
using std::in_place_index;
using std::in_place_t;
using std::in_place_type_t;
using std::in_place_index_t;
using std::in_place_t;
using std::in_place_type;
using std::in_place_type_t;
#define nonstd_lite_in_place_t( T) std::in_place_t
#define nonstd_lite_in_place_type_t( T) std::in_place_type_t<T>
#define nonstd_lite_in_place_t(T) std::in_place_t
#define nonstd_lite_in_place_type_t(T) std::in_place_type_t<T>
#define nonstd_lite_in_place_index_t(K) std::in_place_index_t<K>
#define nonstd_lite_in_place( T) std::in_place_t{}
#define nonstd_lite_in_place_type( T) std::in_place_type_t<T>{}
#define nonstd_lite_in_place_index(K) std::in_place_index_t<K>{}
#define nonstd_lite_in_place(T) \
std::in_place_t {}
#define nonstd_lite_in_place_type(T) \
std::in_place_type_t<T> {}
#define nonstd_lite_in_place_index(K) \
std::in_place_index_t<K> {}
} // namespace nonstd
}// namespace nonstd
#else // any_CPP17_OR_GREATER
#else// any_CPP17_OR_GREATER
#include <cstddef>
namespace nonstd {
namespace detail {
template< class T >
template<class T>
struct in_place_type_tag {};
template< std::size_t K >
template<std::size_t K>
struct in_place_index_tag {};
} // namespace detail
}// namespace detail
struct in_place_t {};
template< class T >
inline in_place_t in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
template<class T>
inline in_place_t
in_place(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>())
{
return in_place_t();
}
template< std::size_t K >
inline in_place_t in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
template<std::size_t K>
inline in_place_t
in_place(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>())
{
return in_place_t();
}
template< class T >
inline in_place_t in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
template<class T>
inline in_place_t
in_place_type(detail::in_place_type_tag<T> = detail::in_place_type_tag<T>())
{
return in_place_t();
}
template< std::size_t K >
inline in_place_t in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
template<std::size_t K>
inline in_place_t
in_place_index(detail::in_place_index_tag<K> = detail::in_place_index_tag<K>())
{
return in_place_t();
}
// mimic templated typedef:
#define nonstd_lite_in_place_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
#define nonstd_lite_in_place_type_t( T) nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T> )
#define nonstd_lite_in_place_index_t(K) nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
#define nonstd_lite_in_place_t(T) \
nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
#define nonstd_lite_in_place_type_t(T) \
nonstd::in_place_t (&)(nonstd::detail::in_place_type_tag<T>)
#define nonstd_lite_in_place_index_t(K) \
nonstd::in_place_t (&)(nonstd::detail::in_place_index_tag<K>)
#define nonstd_lite_in_place( T) nonstd::in_place_type<T>
#define nonstd_lite_in_place_type( T) nonstd::in_place_type<T>
#define nonstd_lite_in_place(T) nonstd::in_place_type<T>
#define nonstd_lite_in_place_type(T) nonstd::in_place_type<T>
#define nonstd_lite_in_place_index(K) nonstd::in_place_index<K>
} // namespace nonstd
}// namespace nonstd
#endif // any_CPP17_OR_GREATER
#endif // nonstd_lite_HAVE_IN_PLACE_TYPES
#endif// any_CPP17_OR_GREATER
#endif// nonstd_lite_HAVE_IN_PLACE_TYPES
//
// Using std::any:
@ -188,17 +202,17 @@ inline in_place_t in_place_index( detail::in_place_index_tag<K> = detail::in_pla
namespace nonstd {
using std::any;
using std::any_cast;
using std::make_any;
using std::swap;
using std::bad_any_cast;
}
using std::any;
using std::any_cast;
using std::bad_any_cast;
using std::make_any;
using std::swap;
}// namespace nonstd
#else // any_USES_STD_ANY
#else// any_USES_STD_ANY
#if !any_CPP11_OR_GREATER
#include <algorithm> // std::swap()
#include <algorithm>// std::swap()
#endif
#include <utility>
@ -217,26 +231,29 @@ namespace nonstd {
// MSVC++ 14.1 _MSC_VER >= 1910 any_COMPILER_MSVC_VERSION == 141 (Visual Studio 2017)
// MSVC++ 14.2 _MSC_VER >= 1920 any_COMPILER_MSVC_VERSION == 142 (Visual Studio 2019)
#if defined(_MSC_VER ) && !defined(__clang__)
# define any_COMPILER_MSVC_VER (_MSC_VER )
# define any_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
#if defined(_MSC_VER) && !defined(__clang__)
#define any_COMPILER_MSVC_VER (_MSC_VER)
#define any_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
#else
# define any_COMPILER_MSVC_VER 0
# define any_COMPILER_MSVC_VERSION 0
#define any_COMPILER_MSVC_VER 0
#define any_COMPILER_MSVC_VERSION 0
#endif
#define any_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
#define any_COMPILER_VERSION(major, minor, patch) \
(10 * (10 * (major) + (minor)) + (patch))
#if defined(__clang__)
# define any_COMPILER_CLANG_VERSION any_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
#define any_COMPILER_CLANG_VERSION \
any_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
#else
# define any_COMPILER_CLANG_VERSION 0
#define any_COMPILER_CLANG_VERSION 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
# define any_COMPILER_GNUC_VERSION any_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#define any_COMPILER_GNUC_VERSION \
any_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#else
# define any_COMPILER_GNUC_VERSION 0
#define any_COMPILER_GNUC_VERSION 0
#endif
// half-open range [lo..hi):
@ -244,12 +261,12 @@ namespace nonstd {
// Presence of language and library features:
#define any_HAVE( feature ) ( any_HAVE_##feature )
#define any_HAVE(feature) (any_HAVE_##feature)
#ifdef _HAS_CPP0X
# define any_HAS_CPP0X _HAS_CPP0X
#define any_HAS_CPP0X _HAS_CPP0X
#else
# define any_HAS_CPP0X 0
#define any_HAS_CPP0X 0
#endif
#define any_CPP11_90 (any_CPP11_OR_GREATER || any_COMPILER_MSVC_VER >= 1500)
@ -263,8 +280,7 @@ namespace nonstd {
// Presence of C++11 language features:
#define any_HAVE_CONSTEXPR_11 any_CPP11_140
#define any_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG \
any_CPP11_120
#define any_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG any_CPP11_120
#define any_HAVE_INITIALIZER_LIST any_CPP11_120
#define any_HAVE_NOEXCEPT any_CPP11_140
#define any_HAVE_NULLPTR any_CPP11_100
@ -274,9 +290,9 @@ namespace nonstd {
#define any_HAVE_OVERRIDE any_CPP11_90
#define any_HAVE_REMOVE_REFERENCE any_CPP11_90
#define any_HAVE_TR1_ADD_CONST (!! any_COMPILER_GNUC_VERSION )
#define any_HAVE_TR1_REMOVE_REFERENCE (!! any_COMPILER_GNUC_VERSION )
#define any_HAVE_TR1_TYPE_TRAITS (!! any_COMPILER_GNUC_VERSION )
#define any_HAVE_TR1_ADD_CONST (!!any_COMPILER_GNUC_VERSION)
#define any_HAVE_TR1_REMOVE_REFERENCE (!!any_COMPILER_GNUC_VERSION)
#define any_HAVE_TR1_TYPE_TRAITS (!!any_COMPILER_GNUC_VERSION)
// Presence of C++14 language features:
@ -289,61 +305,61 @@ namespace nonstd {
// Presence of C++ language features:
#if any_HAVE_CONSTEXPR_11
# define any_constexpr constexpr
#define any_constexpr constexpr
#else
# define any_constexpr /*constexpr*/
#define any_constexpr /*constexpr*/
#endif
#if any_HAVE_CONSTEXPR_14
# define any_constexpr14 constexpr
#define any_constexpr14 constexpr
#else
# define any_constexpr14 /*constexpr*/
#define any_constexpr14 /*constexpr*/
#endif
#if any_HAVE_NOEXCEPT
# define any_noexcept noexcept
#define any_noexcept noexcept
#else
# define any_noexcept /*noexcept*/
#define any_noexcept /*noexcept*/
#endif
#if any_HAVE_NULLPTR
# define any_nullptr nullptr
#define any_nullptr nullptr
#else
# define any_nullptr NULL
#define any_nullptr NULL
#endif
#if any_HAVE_NODISCARD
# define any_nodiscard [[nodiscard]]
#define any_nodiscard [[nodiscard]]
#else
# define any_nodiscard /*[[nodiscard]]*/
#define any_nodiscard /*[[nodiscard]]*/
#endif
#if any_HAVE_OVERRIDE
# define any_override override
#define any_override override
#else
# define any_override /*override*/
#define any_override /*override*/
#endif
// additional includes:
#if any_CONFIG_NO_EXCEPTIONS
# include <cassert>
#include <cassert>
#else
# include <typeinfo>
#include <typeinfo>
#endif
#if ! any_HAVE_NULLPTR
# include <cstddef>
#if !any_HAVE_NULLPTR
#include <cstddef>
#endif
#if any_HAVE_INITIALIZER_LIST
# include <initializer_list>
#include <initializer_list>
#endif
#if any_HAVE_TYPE_TRAITS
# include <type_traits>
#include <type_traits>
#elif any_HAVE_TR1_TYPE_TRAITS
# include <tr1/type_traits>
#include <tr1/type_traits>
#endif
// Method enabling
@ -351,16 +367,15 @@ namespace nonstd {
#if any_CPP11_OR_GREATER
#define any_REQUIRES_0(...) \
template< bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0 >
template<bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0>
#define any_REQUIRES_T(...) \
, typename std::enable_if< (__VA_ARGS__), int >::type = 0
, typename std::enable_if<(__VA_ARGS__), int>::type = 0
#define any_REQUIRES_R(R, ...) \
typename std::enable_if<__VA_ARGS__, R>::type
#define any_REQUIRES_R(R, ...) typename std::enable_if<__VA_ARGS__, R>::type
#define any_REQUIRES_A(...) \
, typename std::enable_if<__VA_ARGS__, void*>::type = nullptr
, typename std::enable_if<__VA_ARGS__, void *>::type = nullptr
#endif
@ -368,7 +383,8 @@ namespace nonstd {
// any:
//
namespace nonstd { namespace any_lite {
namespace nonstd {
namespace any_lite {
// C++11 emulation:
@ -384,9 +400,12 @@ using std::tr1::add_const;
#else
template< class T > struct add_const { typedef const T type; };
template<class T>
struct add_const {
typedef const T type;
};
#endif // any_HAVE_ADD_CONST
#endif// any_HAVE_ADD_CONST
#if any_HAVE_REMOVE_REFERENCE
@ -398,286 +417,281 @@ using std::tr1::remove_reference;
#else
template< class T > struct remove_reference { typedef T type; };
template< class T > struct remove_reference<T&> { typedef T type; };
template<class T>
struct remove_reference {
typedef T type;
};
#endif // any_HAVE_REMOVE_REFERENCE
template<class T>
struct remove_reference<T &> {
typedef T type;
};
} // namespace std11
#endif// any_HAVE_REMOVE_REFERENCE
}// namespace std11
namespace detail {
// for any_REQUIRES_T
/*enum*/ class enabler{};
/*enum*/ class enabler {};
} // namespace detail
}// namespace detail
#if ! any_CONFIG_NO_EXCEPTIONS
#if !any_CONFIG_NO_EXCEPTIONS
class bad_any_cast : public std::bad_cast
{
class bad_any_cast : public std::bad_cast {
public:
#if any_CPP11_OR_GREATER
virtual const char* what() const any_noexcept any_override
virtual const char *what() const any_noexcept any_override
#else
virtual const char* what() const throw()
virtual const char *what() const throw()
#endif
{
return "any-lite: bad any_cast";
}
};
#endif // any_CONFIG_NO_EXCEPTIONS
#endif// any_CONFIG_NO_EXCEPTIONS
class any
{
class any {
public:
any_constexpr any() any_noexcept
: content( any_nullptr )
{}
any_constexpr any() any_noexcept : content(any_nullptr) {}
any( any const & other )
: content( other.content ? other.content->clone() : any_nullptr )
any(any const &other)
: content(other.content ? other.content->clone() : any_nullptr)
{}
#if any_CPP11_OR_GREATER
any( any && other ) any_noexcept
: content( std::move( other.content ) )
any(any &&other) any_noexcept : content(std::move(other.content))
{
other.content = any_nullptr;
}
template<
class ValueType, class T = typename std::decay<ValueType>::type
any_REQUIRES_T( ! std::is_same<T, any>::value )
>
any( ValueType && value ) any_noexcept
: content( new holder<T>( std::forward<ValueType>( value ) ) )
template<class ValueType,
class T = typename std::decay<ValueType>::type any_REQUIRES_T(
!std::is_same<T, any>::value)>
any(ValueType &&value) any_noexcept
: content(new holder<T>(std::forward<ValueType>(value)))
{}
template<
class T, class... Args
any_REQUIRES_T( std::is_constructible<T, Args&&...>::value )
>
explicit any( nonstd_lite_in_place_type_t(T), Args&&... args )
: content( new holder<T>( T( std::forward<Args>(args)... ) ) )
template<class T,
class... Args any_REQUIRES_T(
std::is_constructible<T, Args &&...>::value)>
explicit any(nonstd_lite_in_place_type_t(T), Args &&...args)
: content(new holder<T>(T(std::forward<Args>(args)...)))
{}
template<
class T, class U, class... Args
any_REQUIRES_T( std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value )
>
explicit any( nonstd_lite_in_place_type_t(T), std::initializer_list<U> il, Args&&... args )
: content( new holder<T>( T( il, std::forward<Args>(args)... ) ) )
template<class T,
class U,
class... Args any_REQUIRES_T(
std::is_constructible<T,
std::initializer_list<U> &,
Args &&...>::value)>
explicit any(nonstd_lite_in_place_type_t(T),
std::initializer_list<U> il,
Args &&...args)
: content(new holder<T>(T(il, std::forward<Args>(args)...)))
{}
#else
template< class ValueType >
any( ValueType const & value )
: content( new holder<ValueType>( value ) )
template<class ValueType>
any(ValueType const &value) : content(new holder<ValueType>(value))
{}
#endif // any_CPP11_OR_GREATER
#endif// any_CPP11_OR_GREATER
~any()
{
reset();
}
~any() { reset(); }
any & operator=( any const & other )
any &operator=(any const &other)
{
any( other ).swap( *this );
any(other).swap(*this);
return *this;
}
#if any_CPP11_OR_GREATER
any & operator=( any && other ) any_noexcept
any &operator=(any &&other) any_noexcept
{
any( std::move( other ) ).swap( *this );
any(std::move(other)).swap(*this);
return *this;
}
template<
class ValueType, class T = typename std::decay<ValueType>::type
any_REQUIRES_T( ! std::is_same<T, any>::value )
>
any & operator=( T && value )
template<class ValueType,
class T = typename std::decay<ValueType>::type any_REQUIRES_T(
!std::is_same<T, any>::value)>
any &operator=(T &&value)
{
any( std::move( value ) ).swap( *this );
any(std::move(value)).swap(*this);
return *this;
}
template< class T, class... Args >
void emplace( Args && ... args )
template<class T, class... Args>
void emplace(Args &&...args)
{
any( T( std::forward<Args>(args)... ) ).swap( *this );
any(T(std::forward<Args>(args)...)).swap(*this);
}
template<
class T, class U, class... Args
any_REQUIRES_T( std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value )
>
void emplace( std::initializer_list<U> il, Args&&... args )
template<class T,
class U,
class... Args any_REQUIRES_T(
std::is_constructible<T,
std::initializer_list<U> &,
Args &&...>::value)>
void emplace(std::initializer_list<U> il, Args &&...args)
{
any( T( il, std::forward<Args>(args)... ) ).swap( *this );
any(T(il, std::forward<Args>(args)...)).swap(*this);
}
#else
template< class ValueType >
any & operator=( ValueType const & value )
template<class ValueType>
any &operator=(ValueType const &value)
{
any( value ).swap( *this );
any(value).swap(*this);
return *this;
}
#endif // any_CPP11_OR_GREATER
#endif// any_CPP11_OR_GREATER
void reset() any_noexcept
{
delete content; content = any_nullptr;
delete content;
content = any_nullptr;
}
void swap( any & other ) any_noexcept
{
std::swap( content, other.content );
}
void swap(any &other) any_noexcept { std::swap(content, other.content); }
bool has_value() const any_noexcept
{
return content != any_nullptr;
}
bool has_value() const any_noexcept { return content != any_nullptr; }
const std::type_info & type() const any_noexcept
const std::type_info &type() const any_noexcept
{
return has_value() ? content->type() : typeid( void );
return has_value() ? content->type() : typeid(void);
}
//
// non-standard:
//
template< class ValueType >
const ValueType * to_ptr() const
template<class ValueType>
const ValueType *to_ptr() const
{
return &( static_cast<holder<ValueType> *>( content )->held );
return &(static_cast<holder<ValueType> *>(content)->held);
}
template< class ValueType >
ValueType * to_ptr()
template<class ValueType>
ValueType *to_ptr()
{
return &( static_cast<holder<ValueType> *>( content )->held );
return &(static_cast<holder<ValueType> *>(content)->held);
}
private:
class placeholder
{
class placeholder {
public:
virtual ~placeholder()
{
}
virtual ~placeholder() {}
virtual std::type_info const & type() const = 0;
virtual std::type_info const &type() const = 0;
virtual placeholder * clone() const = 0;
virtual placeholder *clone() const = 0;
};
template< typename ValueType >
class holder : public placeholder
{
template<typename ValueType>
class holder : public placeholder {
public:
holder( ValueType const & value )
: held( value )
{}
holder(ValueType const &value) : held(value) {}
#if any_CPP11_OR_GREATER
holder( ValueType && value )
: held( std::move( value ) )
{}
holder(ValueType &&value) : held(std::move(value)) {}
#endif
virtual std::type_info const & type() const any_override
virtual std::type_info const &type() const any_override
{
return typeid( ValueType );
return typeid(ValueType);
}
virtual placeholder * clone() const any_override
virtual placeholder *clone() const any_override
{
return new holder( held );
return new holder(held);
}
ValueType held;
};
placeholder * content;
placeholder *content;
};
inline void swap( any & x, any & y ) any_noexcept
inline void
swap(any &x, any &y) any_noexcept
{
x.swap( y );
x.swap(y);
}
#if any_CPP11_OR_GREATER
template< class T, class ...Args >
inline any make_any( Args&& ...args )
template<class T, class... Args>
inline any
make_any(Args &&...args)
{
return any( nonstd_lite_in_place_type(T), std::forward<Args>(args)...);
return any(nonstd_lite_in_place_type(T), std::forward<Args>(args)...);
}
template< class T, class U, class ...Args >
inline any make_any( std::initializer_list<U> il, Args&& ...args )
template<class T, class U, class... Args>
inline any
make_any(std::initializer_list<U> il, Args &&...args)
{
return any( nonstd_lite_in_place_type(T), il, std::forward<Args>(args)...);
return any(nonstd_lite_in_place_type(T), il, std::forward<Args>(args)...);
}
#endif // any_CPP11_OR_GREATER
#endif// any_CPP11_OR_GREATER
template<
class ValueType
template<class ValueType
#if any_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG
// any_REQUIRES_T(...) Allow for VC120 (VS2013):
, typename = typename std::enable_if< (std::is_reference<ValueType>::value || std::is_copy_constructible<ValueType>::value), nonstd::any_lite::detail::enabler >::type
// any_REQUIRES_T(...) Allow for VC120 (VS2013):
,
typename = typename std::enable_if<
(std::is_reference<ValueType>::value
|| std::is_copy_constructible<ValueType>::value),
nonstd::any_lite::detail::enabler>::type
#endif
>
any_nodiscard inline ValueType any_cast( any const & operand )
>
any_nodiscard inline ValueType
any_cast(any const &operand)
{
const ValueType * result = any_cast< typename std11::add_const< typename std11::remove_reference<ValueType>::type >::type >( &operand );
const ValueType *result = any_cast<typename std11::add_const<
typename std11::remove_reference<ValueType>::type>::type>(&operand);
#if any_CONFIG_NO_EXCEPTIONS
assert( result );
assert(result);
#else
if ( ! result )
{
throw bad_any_cast();
}
if (!result) { throw bad_any_cast(); }
#endif
return *result;
}
template<
class ValueType
template<class ValueType
#if any_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG
// any_REQUIRES_T(...) Allow for VC120 (VS2013):
, typename = typename std::enable_if< (std::is_reference<ValueType>::value || std::is_copy_constructible<ValueType>::value), nonstd::any_lite::detail::enabler >::type
// any_REQUIRES_T(...) Allow for VC120 (VS2013):
,
typename = typename std::enable_if<
(std::is_reference<ValueType>::value
|| std::is_copy_constructible<ValueType>::value),
nonstd::any_lite::detail::enabler>::type
#endif
>
any_nodiscard inline ValueType any_cast( any & operand )
>
any_nodiscard inline ValueType
any_cast(any &operand)
{
const ValueType * result = any_cast< typename std11::remove_reference<ValueType>::type >( &operand );
const ValueType *result =
any_cast<typename std11::remove_reference<ValueType>::type>(&operand);
#if any_CONFIG_NO_EXCEPTIONS
assert( result );
assert(result);
#else
if ( ! result )
{
throw bad_any_cast();
}
if (!result) { throw bad_any_cast(); }
#endif
return *result;
@ -685,48 +699,57 @@ any_nodiscard inline ValueType any_cast( any & operand )
#if any_CPP11_OR_GREATER
template<
class ValueType
template<class ValueType
#if any_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG
any_REQUIRES_T( std::is_reference<ValueType>::value || std::is_copy_constructible<ValueType>::value )
any_REQUIRES_T(std::is_reference<ValueType>::value
|| std::is_copy_constructible<ValueType>::value)
#endif
>
any_nodiscard inline ValueType any_cast( any && operand )
>
any_nodiscard inline ValueType
any_cast(any &&operand)
{
const ValueType * result = any_cast< typename std11::remove_reference<ValueType>::type >( &operand );
const ValueType *result =
any_cast<typename std11::remove_reference<ValueType>::type>(&operand);
#if any_CONFIG_NO_EXCEPTIONS
assert( result );
assert(result);
#else
if ( ! result )
{
throw bad_any_cast();
}
if (!result) { throw bad_any_cast(); }
#endif
return *result;
}
#endif // any_CPP11_OR_GREATER
#endif// any_CPP11_OR_GREATER
template< class ValueType >
any_nodiscard inline ValueType const * any_cast( any const * operand ) any_noexcept
template<class ValueType>
any_nodiscard inline ValueType const *
any_cast(any const *operand) any_noexcept
{
return operand != any_nullptr && operand->type() == typeid(ValueType) ? operand->to_ptr<ValueType>() : any_nullptr;
return operand != any_nullptr && operand->type() == typeid(ValueType)
? operand->to_ptr<ValueType>()
: any_nullptr;
}
template<class ValueType >
any_nodiscard inline ValueType * any_cast( any * operand ) any_noexcept
template<class ValueType>
any_nodiscard inline ValueType *
any_cast(any *operand) any_noexcept
{
return operand != any_nullptr && operand->type() == typeid(ValueType) ? operand->to_ptr<ValueType>() : any_nullptr;
return operand != any_nullptr && operand->type() == typeid(ValueType)
? operand->to_ptr<ValueType>()
: any_nullptr;
}
} // namespace any_lite
}// namespace any_lite
using namespace any_lite;
} // namespace nonstd
}// namespace nonstd
#endif // any_USES_STD_ANY
namespace ulib {
using namespace nonstd::any_lite;
}
#endif // NONSTD_ANY_LITE_HPP
#endif// any_USES_STD_ANY
#endif// NONSTD_ANY_LITE_HPP