Line data    Source code

       1             : //
       2             : // Copyright (c) 2012-2019 Antony Polukhin.
       3             : //
       4             : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5             : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6             : //
       7             : 
       8             : #ifndef BOOST_TYPE_INDEX_HPP
       9             : #define BOOST_TYPE_INDEX_HPP
      10             : 
      11             : /// \file boost/type_index.hpp
      12             : /// \brief Includes minimal set of headers required to use the Boost.TypeIndex library.
      13             : ///
      14             : /// By inclusion of this file most optimal type index classes will be included and used 
      15             : /// as a boost::typeindex::type_index and boost::typeindex::type_info.
      16             : 
      17             : #include <boost/config.hpp>
      18             : 
      19             : #ifdef BOOST_HAS_PRAGMA_ONCE
      20             : # pragma once
      21             : #endif
      22             : 
      23             : #if defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
      24             : #   include BOOST_TYPE_INDEX_USER_TYPEINDEX
      25             : #   ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
      26             : #       pragma detect_mismatch( "boost__type_index__abi", "user defined type_index class is used: " BOOST_STRINGIZE(BOOST_TYPE_INDEX_USER_TYPEINDEX))
      27             : #   endif
      28             : #elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
      29             : #   include <boost/type_index/stl_type_index.hpp>
      30             : #   if defined(BOOST_NO_RTTI) || defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)
      31             : #       include <boost/type_index/detail/stl_register_class.hpp>
      32             : #       ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
      33             : #           pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - typeid() is used only for templates")
      34             : #       endif
      35             : #   else
      36             : #       ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
      37             : #           pragma detect_mismatch( "boost__type_index__abi", "RTTI is used")
      38             : #       endif
      39             : #   endif
      40             : #else
      41             : #   include <boost/type_index/ctti_type_index.hpp>
      42             : #   include <boost/type_index/detail/ctti_register_class.hpp>
      43             : #   ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
      44             : #       pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - using CTTI")
      45             : #   endif
      46             : #endif
      47             : 
      48             : #ifndef BOOST_TYPE_INDEX_REGISTER_CLASS
      49             : #define BOOST_TYPE_INDEX_REGISTER_CLASS
      50             : #endif
      51             : 
      52             : namespace boost { namespace typeindex {
      53             : 
      54             : #if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
      55             : 
      56             : /// \def BOOST_TYPE_INDEX_FUNCTION_SIGNATURE
      57             : /// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is used by boost::typeindex::ctti_type_index class to
      58             : /// deduce the name of a type. If your compiler is not recognized
      59             : /// by the TypeIndex library and you wish to work with boost::typeindex::ctti_type_index, you may
      60             : /// define this macro by yourself.
      61             : ///
      62             : /// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE must be defined to a compiler specific macro
      63             : /// that outputs the \b whole function signature \b including \b template \b parameters.
      64             : ///
      65             : /// If your compiler is not recognised and BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is not defined,
      66             : /// then a compile-time error will arise at any attempt to use boost::typeindex::ctti_type_index classes.
      67             : ///
      68             : /// See BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS and BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
      69             : /// for an information of how to tune the implementation to make a nice pretty_name() output.
      70             : #define BOOST_TYPE_INDEX_FUNCTION_SIGNATURE BOOST_CURRENT_FUNCTION
      71             : 
      72             : /// \def BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
      73             : /// This is a helper macro for making correct pretty_names() with RTTI off.
      74             : ///
      75             : /// BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING macro may be defined to
      76             : /// '(begin_skip, end_skip, runtime_skip, runtime_skip_until)' with parameters for adding a
      77             : /// support for compilers, that by default are not recognized by TypeIndex library.
      78             : ///
      79             : /// \b Example:
      80             : ///
      81             : /// Imagine the situation when
      82             : /// \code boost::typeindex::ctti_type_index::type_id<int>().pretty_name() \endcode
      83             : /// returns the following string:
      84             : /// \code "static const char *boost::detail::ctti<int>::n() [T = int]" \endcode
      85             : /// and \code boost::typeindex::ctti_type_index::type_id<short>().pretty_name() \endcode returns the following:
      86             : /// \code "static const char *boost::detail::ctti<short>::n() [T = short]" \endcode
      87             : ///
      88             : /// As we may see first 39 characters are "static const char *boost::detail::ctti<" and they do not depend on
      89             : /// the type T. After first 39 characters we have a human readable type name which is duplicated at the end
      90             : /// of a string. String always ends on ']', which consumes 1 character.
      91             : ///
      92             : /// Now if we define `BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING` to
      93             : /// `(39, 1, false, "")` we'll be getting \code "int>::n() [T = int" \endcode
      94             : /// for `boost::typeindex::ctti_type_index::type_id<int>().pretty_name()` and \code "short>::n() [T = short" \endcode
      95             : /// for `boost::typeindex::ctti_type_index::type_id<short>().pretty_name()`.
      96             : ///
      97             : /// Now we need to take additional care of the characters that go before the last mention of our type. We'll
      98             : /// do that by telling the macro that we need to cut off everything that goes before the "T = " including the "T = "
      99             : /// itself:
     100             : ///
     101             : /// \code (39, 1, true, "T = ") \endcode
     102             : ///
     103             : /// In case of GCC or Clang command line we need to add the following line while compiling all the sources:
     104             : ///
     105             : /// \code
     106             : /// -DBOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING='(39, 1, true, "T = ")'
     107             : /// \endcode
     108             : /// \param begin_skip How many characters must be skipped at the beginning of the type holding string.
     109             : /// Must be a compile time constant.
     110             : /// \param end_skip How many characters must be skipped at the end of the type holding string.
     111             : /// Must be a compile time constant.
     112             : /// \param runtime_skip Do we need additional checks at runtime to cut off the more characters.
     113             : /// Must be `true` or `false`.
     114             : /// \param runtime_skip_until Skip all the characters before the following string (including the string itself).
     115             : /// Must be a compile time array of characters.
     116             : ///
     117             : /// See [RTTI emulation limitations](boost_typeindex/rtti_emulation_limitations.html) for more info.
     118             : #define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING (0, 0, false, "")
     119             : 
     120             : 
     121             :     /// Depending on a compiler flags, optimal implementation of type_index will be used 
     122             :     /// as a default boost::typeindex::type_index.
     123             :     ///
     124             :     /// Could be a boost::typeindex::stl_type_index, boost::typeindex::ctti_type_index or 
     125             :     /// user defined type_index class.
     126             :     ///
     127             :     /// \b See boost::typeindex::type_index_facade for a full description of type_index functions.
     128             :     typedef platform_specific type_index;
     129             : #elif defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
     130             :     // Nothing to do
     131             : #elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
     132             :     typedef boost::typeindex::stl_type_index type_index;
     133             : #else 
     134             :     typedef boost::typeindex::ctti_type_index type_index;
     135             : #endif
     136             : 
     137             : /// Depending on a compiler flags, optimal implementation of type_info will be used 
     138             : /// as a default boost::typeindex::type_info.
     139             : ///
     140             : /// Could be a std::type_info, boost::typeindex::detail::ctti_data or 
     141             : /// some user defined class.
     142             : ///
     143             : /// type_info \b is \b not copyable or default constructible. It is \b not assignable too!
     144             : typedef type_index::type_info_t type_info;
     145             : 
     146             : #if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
     147             : 
     148             : /// \def BOOST_TYPE_INDEX_USER_TYPEINDEX
     149             : /// BOOST_TYPE_INDEX_USER_TYPEINDEX can be defined to the path to header file
     150             : /// with user provided implementation of type_index.
     151             : ///
     152             : /// See [Making a custom type_index](boost_typeindex/making_a_custom_type_index.html) section
     153             : /// of documentation for usage example.
     154             : #define BOOST_TYPE_INDEX_USER_TYPEINDEX <full/absolute/path/to/header/with/type_index.hpp>
     155             : 
     156             : 
     157             : /// \def BOOST_TYPE_INDEX_REGISTER_CLASS
     158             : /// BOOST_TYPE_INDEX_REGISTER_CLASS is used to help to emulate RTTI.
     159             : /// Put this macro into the public section of polymorphic class to allow runtime type detection.
     160             : ///
     161             : /// Depending on the typeid() availability this macro will expand to nothing or to virtual helper function
     162             : /// `virtual const type_info& boost_type_info_type_id_runtime_() const noexcept`.
     163             : ///
     164             : /// \b Example:
     165             : /// \code
     166             : /// class A {
     167             : /// public:
     168             : ///     BOOST_TYPE_INDEX_REGISTER_CLASS
     169             : ///     virtual ~A(){}
     170             : /// };
     171             : ///
     172             : /// struct B: public A {
     173             : ///     BOOST_TYPE_INDEX_REGISTER_CLASS
     174             : /// };
     175             : ///
     176             : /// struct C: public B {
     177             : ///     BOOST_TYPE_INDEX_REGISTER_CLASS
     178             : /// };
     179             : ///
     180             : /// ...
     181             : ///
     182             : /// C c1;
     183             : /// A* pc1 = &c1;
     184             : /// assert(boost::typeindex::type_id<C>() == boost::typeindex::type_id_runtime(*pc1));
     185             : /// \endcode
     186             : #define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
     187             : 
     188             : /// \def BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
     189             : /// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY is a helper macro that must be defined if mixing
     190             : /// RTTI on/off modules. See
     191             : /// [Mixing sources with RTTI on and RTTI off](boost_typeindex/mixing_sources_with_rtti_on_and_.html)
     192             : /// section of documentation for more info.
     193             : #define BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
     194             : 
     195             : #endif // defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
     196             : 
     197             : 
     198             : /// Function to get boost::typeindex::type_index for a type T.
     199             : /// Removes const, volatile && and & modifiers from T.
     200             : ///
     201             : /// \b Example:
     202             : /// \code
     203             : /// type_index ti = type_id<int&>();
     204             : /// std::cout << ti.pretty_name();  // Outputs 'int'
     205             : /// \endcode
     206             : ///
     207             : /// \tparam T Type for which type_index must be created.
     208             : /// \throw Nothing.
     209             : /// \return boost::typeindex::type_index with information about the specified type T.
     210             : template <class T>
     211          16 : inline type_index type_id() BOOST_NOEXCEPT {
     212             :     return type_index::type_id<T>();
     213             : }
     214             : 
     215             : /// Function for constructing boost::typeindex::type_index instance for type T. 
     216             : /// Does not remove const, volatile, & and && modifiers from T.
     217             : ///
     218             : /// If T has no const, volatile, & and && modifiers, then returns exactly 
     219             : /// the same result as in case of calling `type_id<T>()`.
     220             : ///
     221             : /// \b Example:
     222             : /// \code
     223             : /// type_index ti = type_id_with_cvr<int&>();
     224             : /// std::cout << ti.pretty_name();  // Outputs 'int&'
     225             : /// \endcode
     226             : ///
     227             : /// \tparam T Type for which type_index must be created.
     228             : /// \throw Nothing.
     229             : /// \return boost::typeindex::type_index with information about the specified type T.
     230             : template <class T>
     231             : inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
     232             :     return type_index::type_id_with_cvr<T>();
     233             : }
     234             : 
     235             : /// Function that works exactly like C++ typeid(rtti_val) call, but returns boost::type_index.
     236             : ///
     237             : /// Returns runtime information about specified type.
     238             : ///
     239             : /// \b Requirements: RTTI available or Base and Derived classes must be marked with BOOST_TYPE_INDEX_REGISTER_CLASS.
     240             : ///
     241             : /// \b Example:
     242             : /// \code
     243             : /// struct Base { virtual ~Base(){} };
     244             : /// struct Derived: public Base  {};
     245             : /// ...
     246             : /// Derived d;
     247             : /// Base& b = d;
     248             : /// type_index ti = type_id_runtime(b);
     249             : /// std::cout << ti.pretty_name();  // Outputs 'Derived'
     250             : /// \endcode
     251             : ///
     252             : /// \param runtime_val Variable which runtime type must be returned.
     253             : /// \throw Nothing.
     254             : /// \return boost::typeindex::type_index with information about the specified variable.
     255             : template <class T>
     256             : inline type_index type_id_runtime(const T& runtime_val) BOOST_NOEXCEPT {
     257             :     return type_index::type_id_runtime(runtime_val);
     258             : }
     259             : 
     260             : }} // namespace boost::typeindex
     261             : 
     262             : 
     263             : 
     264             : #endif // BOOST_TYPE_INDEX_HPP
     265             :