RubyGems - passenger - Versions diffs - 6.0.18 → 6.0.20 - Mend

passenger 6.0.18 → 6.0.20

Files changed (907) hide show

data/src/cxx_supportlib/vendor-modified/boost/type_index/type_index_facade.hpp DELETED Viewed

@@ -1,297 +0,0 @@
-//
-// Copyright 2013-2022 Antony Polukhin.
-//
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
-#define BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
-#include <boost/config.hpp>
-#include <boost/container_hash/hash_fwd.hpp>
-#include <string>
-#include <cstring>
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
-#include <iosfwd>               // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-#ifdef BOOST_HAS_PRAGMA_ONCE
-# pragma once
-#endif
-namespace boost { namespace typeindex {
-/// \class type_index_facade
-///
-/// This class takes care about the comparison operators, hash functions and
-/// ostream operators. Use this class as a public base class for defining new
-/// type_info-conforming classes.
-///
-/// \b Example:
-/// \code
-/// class stl_type_index: public type_index_facade<stl_type_index, std::type_info>
-/// {
-/// public:
-///     typedef std::type_info type_info_t;
-/// private:
-///     const type_info_t* data_;
-///
-/// public:
-///     stl_type_index(const type_info_t& data) noexcept
-///         : data_(&data)
-///     {}
-/// // ...
-/// };
-/// \endcode
-///
-/// \tparam Derived Class derived from type_index_facade.
-/// \tparam TypeInfo Class that will be used as a base type_info class.
-/// \note Take a look at the protected methods. They are \b not \b defined in type_index_facade.
-/// Protected member functions raw_name() \b must be defined in Derived class. All the other
-/// methods are mandatory.
-/// \see 'Making a custom type_index' section for more information about
-/// creating your own type_index using type_index_facade.
-template <class Derived, class TypeInfo>
-class type_index_facade {
-private:
-    /// @cond
-    BOOST_CXX14_CONSTEXPR const Derived & derived() const BOOST_NOEXCEPT {
-      return *static_cast<Derived const*>(this);
-    }
-    /// @endcond
-public:
-    typedef TypeInfo                                type_info_t;
-    /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
-    /// \return Name of a type. By default returns Derived::raw_name().
-    inline const char* name() const BOOST_NOEXCEPT {
-        return derived().raw_name();
-    }
-    /// \b Override: This function \b may be redefined in Derived class. Overrides may throw.
-    /// \return Human readable type name. By default returns Derived::name().
-    inline std::string pretty_name() const {
-        return derived().name();
-    }
-    /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
-    /// \return True if two types are equal. By default compares types by raw_name().
-    inline bool equal(const Derived& rhs) const BOOST_NOEXCEPT {
-        const char* const left = derived().raw_name();
-        const char* const right = rhs.raw_name();
-        return left == right || !std::strcmp(left, right);
-    }
-    /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
-    /// \return True if rhs is greater than this. By default compares types by raw_name().
-    inline bool before(const Derived& rhs) const BOOST_NOEXCEPT {
-        const char* const left = derived().raw_name();
-        const char* const right = rhs.raw_name();
-        return left != right && std::strcmp(left, right) < 0;
-    }
-    /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
-    /// \return Hash code of a type. By default hashes types by raw_name().
-    /// \note Derived class header \b must include <boost/container_hash/hash.hpp>, \b unless this function is redefined in
-    /// Derived class to not use boost::hash_range().
-    inline std::size_t hash_code() const BOOST_NOEXCEPT {
-        const char* const name_raw = derived().raw_name();
-        return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
-    }
-#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-protected:
-    /// \b Override: This function \b must be redefined in Derived class. Overrides \b must not throw.
-    /// \return Pointer to unredable/raw type name.
-    inline const char* raw_name() const BOOST_NOEXCEPT;
-    /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
-    /// \return Const reference to underlying low level type_info_t.
-    inline const type_info_t& type_info() const BOOST_NOEXCEPT;
-    /// This is a factory method that is used to create instances of Derived classes.
-    /// boost::typeindex::type_id() will call this method, if Derived has same type as boost::typeindex::type_index.
-    ///
-    /// \b Override: This function \b may be redefined and made public in Derived class. Overrides \b must not throw.
-    /// Overrides \b must remove const, volatile && and & modifiers from T.
-    /// \tparam T Type for which type_index must be created.
-    /// \return type_index for type T.
-    template <class T>
-    static Derived type_id() BOOST_NOEXCEPT;
-    /// This is a factory method that is used to create instances of Derived classes.
-    /// boost::typeindex::type_id_with_cvr() will call this method, if Derived has same type as boost::typeindex::type_index.
-    ///
-    /// \b Override: This function \b may be redefined and made public in Derived class. Overrides \b must not throw.
-    /// Overrides \b must \b not remove const, volatile && and & modifiers from T.
-    /// \tparam T Type for which type_index must be created.
-    /// \return type_index for type T.
-    template <class T>
-    static Derived type_id_with_cvr() BOOST_NOEXCEPT;
-    /// This is a factory method that is used to create instances of Derived classes.
-    /// boost::typeindex::type_id_runtime(const T&) will call this method, if Derived has same type as boost::typeindex::type_index.
-    ///
-    /// \b Override: This function \b may be redefined and made public in Derived class.
-    /// \param variable Variable which runtime type will be stored in type_index.
-    /// \return type_index with runtime type of variable.
-    template <class T>
-    static Derived type_id_runtime(const T& variable) BOOST_NOEXCEPT;
-#endif
-};
-/// @cond
-template <class Derived, class TypeInfo>
-BOOST_CXX14_CONSTEXPR inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
-}
-template <class Derived, class TypeInfo>
-BOOST_CXX14_CONSTEXPR inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));
-}
-template <class Derived, class TypeInfo>
-BOOST_CXX14_CONSTEXPR inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return rhs < lhs;
-}
-template <class Derived, class TypeInfo>
-BOOST_CXX14_CONSTEXPR inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return !(lhs > rhs);
-}
-template <class Derived, class TypeInfo>
-BOOST_CXX14_CONSTEXPR inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return !(lhs < rhs);
-}
-template <class Derived, class TypeInfo>
-BOOST_CXX14_CONSTEXPR inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return !(lhs == rhs);
-}
-// ######################### COMPARISONS with Derived ############################ //
-template <class Derived, class TypeInfo>
-inline bool operator == (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return Derived(lhs) == rhs;
-}
-template <class Derived, class TypeInfo>
-inline bool operator < (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return Derived(lhs) < rhs;
-}
-template <class Derived, class TypeInfo>
-inline bool operator > (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return rhs < Derived(lhs);
-}
-template <class Derived, class TypeInfo>
-inline bool operator <= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return !(Derived(lhs) > rhs);
-}
-template <class Derived, class TypeInfo>
-inline bool operator >= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return !(Derived(lhs) < rhs);
-}
-template <class Derived, class TypeInfo>
-inline bool operator != (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
-    return !(Derived(lhs) == rhs);
-}
-template <class Derived, class TypeInfo>
-inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
-    return lhs == Derived(rhs);
-}
-template <class Derived, class TypeInfo>
-inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
-    return lhs < Derived(rhs);
-}
-template <class Derived, class TypeInfo>
-inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
-    return Derived(rhs) < lhs;
-}
-template <class Derived, class TypeInfo>
-inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
-    return !(lhs > Derived(rhs));
-}
-template <class Derived, class TypeInfo>
-inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
-    return !(lhs < Derived(rhs));
-}
-template <class Derived, class TypeInfo>
-inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
-    return !(lhs == Derived(rhs));
-}
-// ######################### COMPARISONS with Derived END ############################ //
-/// @endcond
-#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-/// noexcept comparison operators for type_index_facade classes.
-bool operator ==, !=, <, ... (const type_index_facade& lhs, const type_index_facade& rhs) noexcept;
-/// noexcept comparison operators for type_index_facade and it's TypeInfo classes.
-bool operator ==, !=, <, ... (const type_index_facade& lhs, const TypeInfo& rhs) noexcept;
-/// noexcept comparison operators for type_index_facade's TypeInfo and type_index_facade classes.
-bool operator ==, !=, <, ... (const TypeInfo& lhs, const type_index_facade& rhs) noexcept;
-#endif
-#ifndef BOOST_NO_IOSTREAM
-#ifdef BOOST_NO_TEMPLATED_IOSTREAMS
-/// @cond
-/// Ostream operator that will output demangled name
-template <class Derived, class TypeInfo>
-inline std::ostream& operator<<(std::ostream& ostr, const type_index_facade<Derived, TypeInfo>& ind) {
-    ostr << static_cast<Derived const&>(ind).pretty_name();
-    return ostr;
-}
-/// @endcond
-#else
-/// Ostream operator that will output demangled name.
-template <class CharT, class TriatT, class Derived, class TypeInfo>
-inline std::basic_ostream<CharT, TriatT>& operator<<(
-    std::basic_ostream<CharT, TriatT>& ostr,
-    const type_index_facade<Derived, TypeInfo>& ind)
-{
-    ostr << static_cast<Derived const&>(ind).pretty_name();
-    return ostr;
-}
-#endif // BOOST_NO_TEMPLATED_IOSTREAMS
-#endif // BOOST_NO_IOSTREAM
-/// This free function is used by Boost's unordered containers.
-/// \note <boost/container_hash/hash.hpp> has to be included if this function is used.
-template <class Derived, class TypeInfo>
-inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) BOOST_NOEXCEPT {
-    return static_cast<Derived const&>(lhs).hash_code();
-}
-}} // namespace boost::typeindex
-#endif // BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP

data/src/cxx_supportlib/vendor-modified/boost/type_index.hpp DELETED Viewed

@@ -1,265 +0,0 @@
-//
-// Copyright 2012-2022 Antony Polukhin.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef BOOST_TYPE_INDEX_HPP
-#define BOOST_TYPE_INDEX_HPP
-/// \file boost/type_index.hpp
-/// \brief Includes minimal set of headers required to use the Boost.TypeIndex library.
-///
-/// By inclusion of this file most optimal type index classes will be included and used
-/// as a boost::typeindex::type_index and boost::typeindex::type_info.
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_PRAGMA_ONCE
-# pragma once
-#endif
-#if defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
-#   include BOOST_TYPE_INDEX_USER_TYPEINDEX
-#   ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#       pragma detect_mismatch( "boost__type_index__abi", "user defined type_index class is used: " BOOST_STRINGIZE(BOOST_TYPE_INDEX_USER_TYPEINDEX))
-#   endif
-#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
-#   include <boost/type_index/stl_type_index.hpp>
-#   if defined(BOOST_NO_RTTI) || defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)
-#       include <boost/type_index/detail/stl_register_class.hpp>
-#       ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#           pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - typeid() is used only for templates")
-#       endif
-#   else
-#       ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#           pragma detect_mismatch( "boost__type_index__abi", "RTTI is used")
-#       endif
-#   endif
-#else
-#   include <boost/type_index/ctti_type_index.hpp>
-#   include <boost/type_index/detail/ctti_register_class.hpp>
-#   ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#       pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - using CTTI")
-#   endif
-#endif
-#ifndef BOOST_TYPE_INDEX_REGISTER_CLASS
-#define BOOST_TYPE_INDEX_REGISTER_CLASS
-#endif
-namespace boost { namespace typeindex {
-#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-/// \def BOOST_TYPE_INDEX_FUNCTION_SIGNATURE
-/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is used by boost::typeindex::ctti_type_index class to
-/// deduce the name of a type. If your compiler is not recognized
-/// by the TypeIndex library and you wish to work with boost::typeindex::ctti_type_index, you may
-/// define this macro by yourself.
-///
-/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE must be defined to a compiler specific macro
-/// that outputs the \b whole function signature \b including \b template \b parameters.
-///
-/// If your compiler is not recognised and BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is not defined,
-/// then a compile-time error will arise at any attempt to use boost::typeindex::ctti_type_index classes.
-///
-/// See BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS and BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
-/// for an information of how to tune the implementation to make a nice pretty_name() output.
-#define BOOST_TYPE_INDEX_FUNCTION_SIGNATURE BOOST_CURRENT_FUNCTION
-/// \def BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
-/// This is a helper macro for making correct pretty_names() with RTTI off.
-///
-/// BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING macro may be defined to
-/// '(begin_skip, end_skip, runtime_skip, runtime_skip_until)' with parameters for adding a
-/// support for compilers, that by default are not recognized by TypeIndex library.
-///
-/// \b Example:
-///
-/// Imagine the situation when
-/// \code boost::typeindex::ctti_type_index::type_id<int>().pretty_name() \endcode
-/// returns the following string:
-/// \code "static const char *boost::detail::ctti<int>::n() [T = int]" \endcode
-/// and \code boost::typeindex::ctti_type_index::type_id<short>().pretty_name() \endcode returns the following:
-/// \code "static const char *boost::detail::ctti<short>::n() [T = short]" \endcode
-///
-/// As we may see first 39 characters are "static const char *boost::detail::ctti<" and they do not depend on
-/// the type T. After first 39 characters we have a human readable type name which is duplicated at the end
-/// of a string. String always ends on ']', which consumes 1 character.
-///
-/// Now if we define `BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING` to
-/// `(39, 1, false, "")` we'll be getting \code "int>::n() [T = int" \endcode
-/// for `boost::typeindex::ctti_type_index::type_id<int>().pretty_name()` and \code "short>::n() [T = short" \endcode
-/// for `boost::typeindex::ctti_type_index::type_id<short>().pretty_name()`.
-///
-/// Now we need to take additional care of the characters that go before the last mention of our type. We'll
-/// do that by telling the macro that we need to cut off everything that goes before the "T = " including the "T = "
-/// itself:
-///
-/// \code (39, 1, true, "T = ") \endcode
-///
-/// In case of GCC or Clang command line we need to add the following line while compiling all the sources:
-///
-/// \code
-/// -DBOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING='(39, 1, true, "T = ")'
-/// \endcode
-/// \param begin_skip How many characters must be skipped at the beginning of the type holding string.
-/// Must be a compile time constant.
-/// \param end_skip How many characters must be skipped at the end of the type holding string.
-/// Must be a compile time constant.
-/// \param runtime_skip Do we need additional checks at runtime to cut off the more characters.
-/// Must be `true` or `false`.
-/// \param runtime_skip_until Skip all the characters before the following string (including the string itself).
-/// Must be a compile time array of characters.
-///
-/// See [RTTI emulation limitations](boost_typeindex/rtti_emulation_limitations.html) for more info.
-#define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING (0, 0, false, "")
-    /// Depending on a compiler flags, optimal implementation of type_index will be used
-    /// as a default boost::typeindex::type_index.
-    ///
-    /// Could be a boost::typeindex::stl_type_index, boost::typeindex::ctti_type_index or
-    /// user defined type_index class.
-    ///
-    /// \b See boost::typeindex::type_index_facade for a full description of type_index functions.
-    typedef platform_specific type_index;
-#elif defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
-    // Nothing to do
-#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
-    typedef boost::typeindex::stl_type_index type_index;
-#else
-    typedef boost::typeindex::ctti_type_index type_index;
-#endif
-/// Depending on a compiler flags, optimal implementation of type_info will be used
-/// as a default boost::typeindex::type_info.
-///
-/// Could be a std::type_info, boost::typeindex::detail::ctti_data or
-/// some user defined class.
-///
-/// type_info \b is \b not copyable or default constructible. It is \b not assignable too!
-typedef type_index::type_info_t type_info;
-#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-/// \def BOOST_TYPE_INDEX_USER_TYPEINDEX
-/// BOOST_TYPE_INDEX_USER_TYPEINDEX can be defined to the path to header file
-/// with user provided implementation of type_index.
-///
-/// See [Making a custom type_index](boost_typeindex/making_a_custom_type_index.html) section
-/// of documentation for usage example.
-#define BOOST_TYPE_INDEX_USER_TYPEINDEX <full/absolute/path/to/header/with/type_index.hpp>
-/// \def BOOST_TYPE_INDEX_REGISTER_CLASS
-/// BOOST_TYPE_INDEX_REGISTER_CLASS is used to help to emulate RTTI.
-/// Put this macro into the public section of polymorphic class to allow runtime type detection.
-///
-/// Depending on the typeid() availability this macro will expand to nothing or to virtual helper function
-/// `virtual const type_info& boost_type_info_type_id_runtime_() const noexcept`.
-///
-/// \b Example:
-/// \code
-/// class A {
-/// public:
-///     BOOST_TYPE_INDEX_REGISTER_CLASS
-///     virtual ~A(){}
-/// };
-///
-/// struct B: public A {
-///     BOOST_TYPE_INDEX_REGISTER_CLASS
-/// };
-///
-/// struct C: public B {
-///     BOOST_TYPE_INDEX_REGISTER_CLASS
-/// };
-///
-/// ...
-///
-/// C c1;
-/// A* pc1 = &c1;
-/// assert(boost::typeindex::type_id<C>() == boost::typeindex::type_id_runtime(*pc1));
-/// \endcode
-#define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
-/// \def BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
-/// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY is a helper macro that must be defined if mixing
-/// RTTI on/off modules. See
-/// [Mixing sources with RTTI on and RTTI off](boost_typeindex/mixing_sources_with_rtti_on_and_.html)
-/// section of documentation for more info.
-#define BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
-#endif // defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-/// Function to get boost::typeindex::type_index for a type T.
-/// Removes const, volatile && and & modifiers from T.
-///
-/// \b Example:
-/// \code
-/// type_index ti = type_id<int&>();
-/// std::cout << ti.pretty_name();  // Outputs 'int'
-/// \endcode
-///
-/// \tparam T Type for which type_index must be created.
-/// \throw Nothing.
-/// \return boost::typeindex::type_index with information about the specified type T.
-template <class T>
-inline type_index type_id() BOOST_NOEXCEPT {
-    return type_index::type_id<T>();
-}
-/// Function for constructing boost::typeindex::type_index instance for type T.
-/// Does not remove const, volatile, & and && modifiers from T.
-///
-/// If T has no const, volatile, & and && modifiers, then returns exactly
-/// the same result as in case of calling `type_id<T>()`.
-///
-/// \b Example:
-/// \code
-/// type_index ti = type_id_with_cvr<int&>();
-/// std::cout << ti.pretty_name();  // Outputs 'int&'
-/// \endcode
-///
-/// \tparam T Type for which type_index must be created.
-/// \throw Nothing.
-/// \return boost::typeindex::type_index with information about the specified type T.
-template <class T>
-inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
-    return type_index::type_id_with_cvr<T>();
-}
-/// Function that works exactly like C++ typeid(rtti_val) call, but returns boost::type_index.
-///
-/// Returns runtime information about specified type.
-///
-/// \b Requirements: RTTI available or Base and Derived classes must be marked with BOOST_TYPE_INDEX_REGISTER_CLASS.
-///
-/// \b Example:
-/// \code
-/// struct Base { virtual ~Base(){} };
-/// struct Derived: public Base  {};
-/// ...
-/// Derived d;
-/// Base& b = d;
-/// type_index ti = type_id_runtime(b);
-/// std::cout << ti.pretty_name();  // Outputs 'Derived'
-/// \endcode
-///
-/// \param runtime_val Variable which runtime type must be returned.
-/// \throw Nothing.
-/// \return boost::typeindex::type_index with information about the specified variable.
-template <class T>
-inline type_index type_id_runtime(const T& runtime_val) BOOST_NOEXCEPT {
-    return type_index::type_id_runtime(runtime_val);
-}
-}} // namespace boost::typeindex
-#endif // BOOST_TYPE_INDEX_HPP