gls_cpp_lang_support.h

Go to the documentation of this file.

/*! \file
  \brief  Macros and helper code to determine what subset of C++11/14/17 is available.
 
  \par Copyright Information
 
  Copyright (c) 2016 The DiSTI Corporation.<br>
  11486 Corporate Blvd; Suite 190<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
*/
 
#ifndef INCLUDED_GLS_CPP_LANG_SUPPORT_H
#define INCLUDED_GLS_CPP_LANG_SUPPORT_H
 
// Conditional C++11/14 support
//
// We use a subset of C++11/14 features to improve efficiency and correctness of code.
//
// We attempt to detect compiler support, but for unusual configurations, it can be
// enabled with project-level defines. Define DISTI_HAS_CPP11 to enable all features.
// Enable specific features by defining any of the following:
//
//   DISTI_HAS_RVAL_REFS             // For rvalue references
//   DISTI_HAS_METHOD_OVERRIDE       // For "override" and "final" keywords
//   DISTI_HAS_NOEXCEPT              // For "noexcept" keyword
//   DISTI_HAS_SPECIAL_MEM_FUN_DEL   // For "= delete"
//   DISTI_HAS_TYPE_TRAITS           // For compile-time checking via type-traits
//   DISTI_HAS_STATIC_ASSERT         // For static_assert support
//   DISTI_HAS_DEPRECATED_ATTRIBUTE  // For [[deprecated("why")]] attribute
//   DISTI_HAS_USER_DEFINED_LITERALS // For operator""_myLiteral
//
// If our detection is incorrect, override it with a corresponding "NO" define:
//
//   DISTI_NO_RVAL_REFS             // For rvalue references
//   DISTI_NO_METHOD_OVERRIDE       // For "override" and "final" keywords
//   DISTI_NO_NOEXCEPT              // For "noexcept" keyword
//   DISTI_NO_SPECIAL_MEM_FUN_DEL   // For "= delete"
//   DISTI_NO_TYPE_TRAITS           // For compile-time checking via type-traits
//   DISTI_NO_STATIC_ASSERT         // For static_assert support
//   DISTI_NO_DEPRECATED_ATTRIBUTE  // For [[deprecated("why")]] attribute
//   DISTI_NO_USER_DEFINED_LITERALS // For operator""_myLiteral
/////////////////////////////////////////////////////////////////////////////////////
// Microsoft C++ Compiler -- https://msdn.microsoft.com/en-us/library/hh567368.aspx
/////////////////////////////////////////////////////////////////////////////////////
#if defined( _MSC_VER )
#    if _MSC_VER >= 1700 // >= VS2012
#        define DISTI_HAS_RVAL_REFS
#        define DISTI_HAS_METHOD_OVERRIDE
#        define DISTI_HAS_TYPE_TRAITS
#        define DISTI_HAS_STATIC_ASSERT
#    endif
#    if _MSC_VER >= 1800 // >= VS2013
#        define DISTI_HAS_SPECIAL_MEM_FUN_DEL
#        define DISTI_HAS_CPP11
#    endif
#    if _MSC_VER >= 1900 // >= VS2015
#        define DISTI_HAS_USER_DEFINED_LITERALS
#    endif
#    if _MSC_VER >= 1911 && __cplusplus >= 201402L // >= VS2017 15.3
#        define DISTI_HAS_NOEXCEPT
#        define DISTI_HAS_DEPRECATED_ATTRIBUTE
#        define DISTI_HAS_CPP14
#    endif
 
////////////////////////////////////////////////////////////////////////////////
// GCC versions -- https://gcc.gnu.org/projects/cxx-status.html#cxx11
////////////////////////////////////////////////////////////////////////////////
#elif defined( __GNUC__ ) && !defined( __clang__ )
// __cpp_rvalue_references doesn't seem to be defined in GCC, despite the documentation, so we have an alternative check also
#    if __cpp_rvalue_references >= 200610 || ( ( __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 3 ) ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L ) )
#        define DISTI_HAS_RVAL_REFS
#    endif
#    if __cpp_static_assert >= 200410 && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L )
#        define DISTI_HAS_STATIC_ASSERT
#    endif
#    if( __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 9 ) ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L )
#        define DISTI_HAS_USER_DEFINED_LITERALS
#    endif
#    if( __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 7 ) ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L )
#        define DISTI_HAS_METHOD_OVERRIDE
#        define DISTI_HAS_NOEXCEPT
#        define DISTI_HAS_TYPE_TRAITS // This actually depends on which standard library is in use, but it's a safe bet.
#        define DISTI_HAS_CPP11
#    endif
#    if( __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 4 ) ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || __cplusplus >= 201103L )
#        define DISTI_HAS_SPECIAL_MEM_FUN_DEL
#    endif
#    if( __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 9 ) ) && __cplusplus >= 201402L
#        define DISTI_HAS_DEPRECATED_ATTRIBUTE
#        define DISTI_HAS_CPP14
#    endif
 
////////////////////////////////////////////////////////////////////////////////
// Clang versions -- http://clang.llvm.org/cxx_status.html
////////////////////////////////////////////////////////////////////////////////
#elif defined( __clang__ )
#    if __has_feature( cxx_rvalue_references )
#        define DISTI_HAS_RVAL_REFS
#        define DISTI_HAS_CPP11 // Guess that if we have rvalue refs, we've got pretty solid C++11 support
#    endif
#    if __has_feature( cxx_override_control )
#        define DISTI_HAS_METHOD_OVERRIDE
#    endif
#    if __has_feature( cxx_noexcept )
#        define DISTI_HAS_NOEXCEPT
#    endif
#    if __has_feature( cxx_defaulted_functions ) && __has_feature( cxx_deleted_functions )
#        define DISTI_HAS_SPECIAL_MEM_FUN_DEL
#    endif
#    if __has_feature( cxx_static_assert )
#        define DISTI_HAS_STATIC_ASSERT
#    endif
#    if __has_feature( cxx_user_literals )
#        define DISTI_HAS_USER_DEFINED_LITERALS
#    endif
#    if( __clang_major__ > 3 || ( __clang_major__ == 3 && __clang_minor__ >= 4 ) ) && __cplusplus >= 201402L
#        define DISTI_HAS_DEPRECATED_ATTRIBUTE
#        define DISTI_HAS_CPP14
#    endif
// This actually depends on which standard library is in use, but it's a safe bet.
#    define DISTI_HAS_TYPE_TRAITS
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
// Shortcut for unrecognized compilers
///////////////////////////////////////////////////////////////////////////////////////////////////
// A single switch to enable everything since compiler is highly compliant
// These macros can help with cross-platform portability
#ifdef DISTI_HAS_CPP14
/// Defines whether or not C++11 support is available.
#    define DISTI_HAS_CPP11
/// Defines whether this compiler supports the C++14 deprecated attribute.
#    define DISTI_HAS_DEPRECATED_ATTRIBUTE
#endif
 
#ifdef DISTI_HAS_CPP11
/// Macro to wrap code that should be excluded if C++11 support is not available.
#    define DISTI_IF_HAS_CPP11( x ) x
/// Macro to wrap code that has two implementations, one for C++11 support and the other without.
#    define DISTI_IF_HAS_CPP11_ELSE( x, y ) x
 
/// Defines whether or not this compiler supports move semantics.
#    define DISTI_HAS_RVAL_REFS
/// Defines whether or not this compiler supports the override keyword.
#    define DISTI_HAS_METHOD_OVERRIDE
/// Defines whether or not this compiler supports deleted functions.
#    define DISTI_HAS_SPECIAL_MEM_FUN_DEL
/// Defines whether or not this compiler supports type traits.
#    define DISTI_HAS_TYPE_TRAITS
/// Defines whether or not this compiler supports static assertion.
#    define DISTI_HAS_STATIC_ASSERT
#else
// Not fully C++11; some features may be enabled piecemeal
// These macros can help with cross-platform portability
#    define DISTI_IF_HAS_CPP11( x )
#    define DISTI_IF_HAS_CPP11_ELSE( x, y ) y
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
// Individual C++11 features. See comment above on DISTI_NO_* vs. DISTI_HAS_* macros.
///////////////////////////////////////////////////////////////////////////////////////////////////
#if !defined( DISTI_NO_RVAL_REFS ) && defined( DISTI_HAS_RVAL_REFS )
#    include <utility>
/// Macro to wrap std::move, removed on compilers that don't support it.
#    define DISTI_RVAL_MOVE( x ) std::move( x )
/// Macro to wrap std::forward, removed on compilers that don't support it.
#    define DISTI_UREF_FORWARD( T, x ) std::forward<T>( x )
/// Macro to wrap r-value reference, removed on playforms that don't support it.
#    define DISTI_UREF( T ) T&&
/// Macro to wrap code that should be excluded if r-value references aren't supported.
#    define DISTI_IF_HAS_RVAL_REFS( x ) x
/// Macro to wrap code that has two implementations, one for r-value reference support, and the other without.
#    define DISTI_IF_HAS_RVAL_REFS_ELSE( x, y ) x
#else
#    undef DISTI_HAS_RVAL_REFS
#    define DISTI_RVAL_MOVE( x ) x
#    define DISTI_UREF_FORWARD( T, x ) x
#    define DISTI_UREF( T ) const T&
#    define DISTI_IF_HAS_RVAL_REFS( x )
#    define DISTI_IF_HAS_RVAL_REFS_ELSE( x, y ) y
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
#if !defined( DISTI_NO_METHOD_OVERRIDE ) && defined( DISTI_HAS_METHOD_OVERRIDE )
/// Macro to wrap the override keyword, removed on compilers that don't support it.
#    define DISTI_METHOD_OVERRIDE override
/// Macro to wrap the final keyword, removed on compilers that don't support it.
#    define DISTI_FINAL final
#else
#    undef DISTI_HAS_METHOD_OVERRIDE
#    define DISTI_METHOD_OVERRIDE
#    define DISTI_FINAL
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
#if !defined( DISTI_NO_NOEXCEPT ) && defined( DISTI_HAS_NOEXCEPT )
#    define DISTI_FUNC_NOEXCEPT noexcept
#else
#    undef DISTI_HAS_NOEXCEPT
/// Macro to wrap the noexcept keyword, removed on compilers that don't support it.
#    define DISTI_FUNC_NOEXCEPT
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
#if !defined( DISTI_NO_SPECIAL_MEM_FUN_DEL ) && defined( DISTI_HAS_SPECIAL_MEM_FUN_DEL )
/// Macro to wrap function deletion, removed on compilers that don't support it.
#    define DISTI_SPECIAL_MEM_FUN_DELETE = delete
#else
#    undef DISTI_HAS_SPECIAL_MEM_FUN_DEL
#    define DISTI_SPECIAL_MEM_FUN_DELETE
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
#if !defined( DISTI_NO_USER_DEFINED_LITERALS ) && defined( DISTI_HAS_USER_DEFINED_LITERALS )
#    define DISTI_IF_HAS_USER_DEFINED_LITERAL( x ) x
#else
#    undef DISTI_HAS_USER_DEFINED_LITERALS
/// Macro to wrap user defined literals, removed on compilers that don't support them.
#    define DISTI_IF_HAS_USER_DEFINED_LITERAL( x )
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
#if !defined( DISTI_NO_TYPE_TRAITS ) && defined( DISTI_HAS_TYPE_TRAITS )
/// Use this by including <type_traits> and then providing a default, e.g.,
/// \code{.cpp}
/// DISTI_IF_HAS_TYPE_TRAITS_ELSE( std::is_const<T>::value, false )
/// \endcode
#    define DISTI_IF_HAS_TYPE_TRAITS_ELSE( x, y ) x
 
////////////////////////////////////////////////////////////////////////////////
/// Convenience macro to check that one type converts to another at compile-time.
/// \param T A class to check
/// \param ConvertsTo A class to test T* against to verify that it can be
///                   converted to ConvertsTo* without a cast.
////////////////////////////////////////////////////////////////////////////////
#    define DISTI_STATIC_ASSERT_IS_CONVERTIBLE_TO( T, ConvertsTo ) DISTI_STATIC_ASSERT( ( std::is_convertible<T*, ConvertsTo*>::value ), class_does_not_inherit_from_##ConvertsTo );
 
/// Determines if a class \a T is trivially destructible (i.e., has no side effects)
#    define DISTI_IS_TRIVIALLY_DESTRUCTIBLE( T ) ( std::is_trivially_destructible<T>() )
/// Macro wrapping std::true_type, removed on compilers that don't support it.
#    define DISTI_TT_TRUE_TYPE std::true_type
/// Macro wrapping std::false_type, removed on compilers that don't support it.
#    define DISTI_TT_FALSE_TYPE std::false_type
#else
#    undef DISTI_HAS_TYPE_TRAITS
#    define DISTI_IF_HAS_TYPE_TRAITS_ELSE( x, y ) y
 
// See documentation above
#    define DISTI_STATIC_ASSERT_IS_CONVERTIBLE_TO( T, ConvertsTo ) DISTI_STATIC_ASSERT( ( ::disti::_cppLangSupportDetail::is_convertible<T*, ConvertsTo*>::value ), class_does_not_inherit_from_##ConvertsTo )
 
// See documentation above
#    define DISTI_IS_TRIVIALLY_DESTRUCTIBLE( T ) ( ::disti::_cppLangSupportDetail::is_trivially_destructible<T>() )
#    define DISTI_TT_TRUE_TYPE ::disti::_cppLangSupportDetail::true_type
#    define DISTI_TT_FALSE_TYPE ::disti::_cppLangSupportDetail::false_type
 
namespace disti
{
// The _cppLangSupportDetail namespace is here to hide implementation details, mostly for things
// that are standard but not available on all supported platforms.
namespace _cppLangSupportDetail
{
    /// Replacement for std::is_convertible, adapted from Loki 0.1.7.
    /////////////////////////////////////////////////////////////////////////////////
    /// \copyright The Loki Library, Copyright (c) 2001 by Andrei Alexandrescu<br />
    /// This code accompanies the book:
    /// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
    ///     Patterns Applied". Copyright (c) 2001. Addison-Wesley.<br />
    /// Permission to use, copy, modify, distribute and sell this software for any
    ///     purpose is hereby granted without fee, provided that the above copyright
    ///     notice appear in all copies and that both that copyright notice and this
    ///     permission notice appear in supporting documentation.<br />
    /// The author or Addison-Welsey Longman make no representations about the
    ///     suitability of this software for any purpose. It is provided "as is"
    ///     without express or implied warranty.<br />
    /////////////////////////////////////////////////////////////////////////////////
    template<class T, class U>
    struct is_convertible
    {
    private:
        typedef char Small;
        struct Big
        {
            char dummy[ 2 ];
        };
        static Big   Test( ... );
        static Small Test( U );
        static T     MakeT();
 
    public:
        enum
        {
            value = sizeof( Small ) == sizeof( ( Test( MakeT() ) ) )
        };
    };
 
    // clang-format off
    template<class T> struct is_convertible<T,    T   > { enum { value = true  }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
    template<class T> struct is_convertible<void, T   > { enum { value = false }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
    template<class T> struct is_convertible<T,    void> { enum { value = false }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
    template<>        struct is_convertible<void, void> { enum { value = true  }; }; //< Replacement for std::is_convertible, adapted from Loki 0.1.7.
 
#    if defined( DISTI_USER_DEFINED_IS_TRIVIALLY_DESTRUCTIBLE ) // Prefer the user-defined version if available
#        define DISTI_TT_IS_TRIVIALLY_DESTRUCTIBLE( T ) ( DISTI_USER_DEFINED_IS_TRIVIALLY_DESTRUCTIBLE( T ) )
#    else
         // Use compiler intrinsics for something that cannot be reliably determined without it.
         // Drawn from Boost 1.55.0's implementation.
#        if defined( _MSC_VER )
#            define DISTI_TT_IS_TRIVIALLY_DESTRUCTIBLE( T ) ( __has_trivial_destructor( T ) || ( __is_pod( T ) && __has_trivial_constructor( T ) ) )
#        else
             // This is defined for all supported versions of GCC and Clang and is also common elsewhere.
             // Define DISTI_USER_DEFINED_IS_TRIVIALLY_DESTRUCTIBLE() to override.
#            define DISTI_TT_IS_TRIVIALLY_DESTRUCTIBLE( T ) ( __has_trivial_destructor( T ) )
#        endif
#    endif
#    if defined( DISTI_USER_DEFINED_IS_DESTRUCTIBLE ) // Prefer the user-defined version if available
#        define DISTI_TT_IS_DESTRUCTIBLE( T ) ( DISTI_USER_DEFINED_IS_DESTRUCTIBLE( T ) )
#    else
         // This is defined for all supported versions of GCC and Clang and is also common elsewhere.
         // Define DISTI_USER_DEFINED_IS_DESTRUCTIBLE() to override.
#        define DISTI_TT_IS_DESTRUCTIBLE( T ) ( __is_pod( T ) || __is_class( T ) )
#    endif
    // clang-format on
 
    template<typename T, T Val>
    struct integral_constant
    {
        static const T                    value;
        typedef T                         value_type;
        typedef integral_constant<T, Val> type;
                                          operator value_type() { return value; }
    };
 
    template<typename T, T Val>
    const T integral_constant<T, Val>::value = Val;
 
    typedef integral_constant<bool, true>  true_type;
    typedef integral_constant<bool, false> false_type;
 
    template<typename T>
    struct is_trivially_destructible
        : integral_constant<bool, DISTI_TT_IS_DESTRUCTIBLE( T ) && DISTI_TT_IS_TRIVIALLY_DESTRUCTIBLE( T )>
    {};
 
} // namespace _cppLangSupportDetail
} // namespace disti
#endif
 
///////////////////////////////////////////////////////////////////////////////////////////////////
#if defined( DISTI_NO_STATIC_ASSERT )
#    undef DISTI_HAS_STATIC_ASSERT
#    define DISTI_STATIC_ASSERT( expr, msg )
#else
  /// Inner macro for preprocessor stringification, do not use this macro directly.
#    define DISTI_PREPROC_STRINGIFY_HELPER( s ) #    s
  /// Use this macro to convert a preprocessor define into a literal string.
#    define DISTI_PREPROC_STRINGIFY( s ) DISTI_PREPROC_STRINGIFY_HELPER( s )
 
#    if defined( DISTI_HAS_STATIC_ASSERT )
  /// \brief Uses C++11's static_assert() because it is available on this platform.
  /// \param expr a compile-time integral or pointer expression
  /// \param msg  a C identifier that will appear in compiler diagnostics
  /// \note For older compilers' benefit, \a msg should be a C identifier such as:
  /// \code{.cpp}
  ///    DISTI_STATIC_ASSERT( (std::is_convertible<T*,ConvertsTo*>::value), class_does_not_inherit_from_##ConvertsTo )
  /// \endcode
  ///  which shows a compile-time error that typically includes: "ERROR_class_does_not_inherit_from_Group".
  ///  If it is not a C identifier, you may get spurious error messages at compile time compilers without static_assert.
#        define DISTI_STATIC_ASSERT( expr, msg ) static_assert( expr, DISTI_PREPROC_STRINGIFY( msg ) )
 
/// \brief Uses C++11's static_assert() because it is available on this platform.
/// \param expr a compile-time integral or pointer expression with a string message.
/// \param msg  a string to help the developer determine what went wrong.
/// \code{.cpp}
///    DISTI_STATIC_ASSERT_STR( (std::is_convertible<T*, Base*>::value), "Class does not inherit from Base." );
/// \endcode
/// \note Adapted from Loki 0.1.7.
#        define DISTI_STATIC_ASSERT_STR( expr, msg ) static_assert( expr, msg )
 
#    else
namespace disti
{
namespace _cppLangSupportDetail
{
    // Helpers for DISTI_STATIC_ASSERT
    // \note Adapted from Loki 0.1.7.
    template<int>
    struct CompileTimeError;
    template<>
    struct CompileTimeError<true>
    {
        CompileTimeError() {}
        CompileTimeError( const char* ) {}
    };
} // namespace _cppLangSupportDetail
} // namespace disti
 
/// \brief Poor man's version of C++11's static_assert()
/// \param expr a compile-time integral or pointer expression
/// \param msg  a C identifier that will appear in compiler diagnostics
/// \note For older compilers' benefit, \a msg should be a C identifier such as:
/// \code{.cpp}
///    DISTI_STATIC_ASSERT( (std::is_convertible<T*, Base*>::value), class_does_not_inherit_from_Base );
/// \endcode
///  which shows a compile-time error that typically includes: "ERROR_class_does_not_inherit_from_Base".
///  If it is not a C identifier, you may get spurious error messages at compile time compilers without static_assert.
/// \note Adapted from Loki 0.1.7.
#        define DISTI_STATIC_ASSERT( expr, msg )                                                 \
            {                                                                                    \
                ::disti::_cppLangSupportDetail::CompileTimeError<( ( expr ) != 0 )> ERROR_##msg; \
                (void)ERROR_##msg;                                                               \
            }
 
/// \param expr a compile-time integral or pointer expression with a string message
/// \param msg  a string to help the developer determine what went wrong.
/// \code{.cpp}
///    DISTI_STATIC_ASSERT_STR( (std::is_convertible<T*, Base*>::value), "Class does not inherit from Base." );
/// \endcode
/// \note Adapted from Loki 0.1.7.
#        define DISTI_STATIC_ASSERT_STR( expr, msg )                                                         \
            {                                                                                                \
                ::disti::_cppLangSupportDetail::CompileTimeError<( ( expr ) != 0 )> ERROR_##__LINE__( msg ); \
                (void)ERROR_##__LINE__;                                                                      \
            }
#    endif
#endif
 
/// Defines whether this compiler supports the C++14 deprecated attribute.
#if defined( DISTI_HAS_DEPRECATED_ATTRIBUTE ) && !defined( DISTI_NO_DEPRECATED_ATTRIBUTE )
#    define DISTI_DEPRECATED( msg ) [[deprecated( msg )]]
#else
#    define DISTI_DEPRECATED( msg )
#endif
 
#include <float.h>
namespace disti
{
// clang-format off
/// \details The MaxDigits10 struct. Since not all platforms support C++11, we provide an equivalent feature here that does not require it.
/// Formulae derived from the proposal for std::numeric_limits<>::max_digits10 (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2005.pdf)
template<class T> struct MaxDigits10              { static const unsigned long value = 0;                                        /**< The number of digits.*/ };
/// \see MaxDigits10
template<>        struct MaxDigits10<float>       { static const unsigned long value = 2 + (FLT_MANT_DIG  * 30103UL) / 100000UL; /**< The number of digits.*/ }; 
/// \see MaxDigits10
template<>        struct MaxDigits10<double>      { static const unsigned long value = 2 + (DBL_MANT_DIG  * 30103UL) / 100000UL; /**< The number of digits.*/ };
/// \see MaxDigits10
template<>        struct MaxDigits10<long double> { static const unsigned long value = 2 + (LDBL_MANT_DIG * 30103UL) / 100000UL; /**< The number of digits.*/ };
// clang-format on
} // namespace disti
 
#include <cstdlib>
#include <typeinfo>
#if defined( __GNUC__ ) || defined( __clang__ )
#    include <cxxabi.h>
#endif
namespace disti
{
template<class T>
 
/// Transforms C++ ABI identifiers into the original C++ source identifiers
/// \return String containing transformed C++ source identifier.
/// \pre none
/// \post none
const char* Demangle()
{
#if defined( __GNUC__ ) || defined( __clang__ )
    static char* s_unmangledName = NULL;
    std::free( s_unmangledName );
 
    // https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html
    int status      = 0;
    s_unmangledName = abi::__cxa_demangle( typeid( T ).name(), NULL, NULL, &status );
 
    if( 0 == status )
    {
        return s_unmangledName;
    }
#endif
    return typeid( T ).name();
}
} // namespace disti
 
#endif