townforge/type_index
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Changed namespace to boost::typeindex

Browse Source
This commit is contained in:
Antony Polukhin 2014-05-04 14:42:12 +04:00
parent a66ffcfa50
commit 5ed8543025
21 changed files with 132 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
doc/type_index.qbk
View File

@ -31,7 +31,7 @@ Boost.TypeIndex library was designed to work around all those issues.
[section Getting started]
`boost::typeind::type_info` is a drop-in replacement for `std::type_info` and `boost::typeind::type_index`
`boost::typeindex::type_info` is a drop-in replacement for `std::type_info` and `boost::typeindex::type_index`
is a drop-in replacement for `std::type_index`. Unlike Standard Library versions those classes may work without RTTI.
`type_index` provides the full set of comparison operators, hashing functions and ostream
@ -53,7 +53,7 @@ To start using Boost.TypeIndex:
[[``
std::type_index
``][``
boost::typeind::type_index
boost::typeindex::type_index
``]]
[[``
@ -62,18 +62,18 @@ To start using Boost.TypeIndex:
typeid(T).name() // not human readable
typeid(variable)
``][``
boost::typeind::type_id<T>()
boost::typeind::type_id_with_cvr<T>()
boost::typeind::type_id<T>().pretty_name() // human readable
boost::typeind::type_id_runtime(variable)
boost::typeindex::type_id<T>()
boost::typeindex::type_id_with_cvr<T>()
boost::typeindex::type_id<T>().pretty_name() // human readable
boost::typeindex::type_id_runtime(variable)
``]]
[[``
const std::type_info& v1 = typeid(int); // when reference to `std::type_info` is required
const std::type_info* v2 = &typeid(int); // other cases
``][``
const boost::typeind::type_info& v1 = boost::typeind::type_id<int>().type_info();
boost::typeind::type_index v2 = boost::typeind::type_id<int>();
const boost::typeindex::type_info& v1 = boost::typeindex::type_id<int>().type_info();
boost::typeindex::type_index v2 = boost::typeindex::type_id<int>();
``]]
]
@ -95,10 +95,10 @@ Here is how TypeIndex could be used in `boost/any.hpp`:
return typeid(ValueType);
}
``] [``
virtual const boost::typeind::type_info & type() const BOOST_NOEXCEPT
virtual const boost::typeindex::type_info & type() const BOOST_NOEXCEPT
{
// now works even with RTTI disabled
return boost::typeind::type_id<ValueType>().type_info();
return boost::typeindex::type_id<ValueType>().type_info();
}
``]]
]
@ -138,14 +138,14 @@ public: // visitor interfaces
#endif // BOOST_NO_TYPEID
``][``
class reflect
: public static_visitor<const boost::typeind::type_info&>
: public static_visitor<const boost::typeindex::type_info&>
{
public: // visitor interfaces
template <typename T>
const boost::typeind::type_info& operator()(const T&) const BOOST_NOEXCEPT
const boost::typeindex::type_info& operator()(const T&) const BOOST_NOEXCEPT
{
return boost::typeind::type_id<T>().type_info();
return boost::typeindex::type_id<T>().type_info();
}
};
@ -159,7 +159,7 @@ public: // visitor interfaces
}
#endif
``] [``
const boost::typeind::type_info& type() const
const boost::typeindex::type_info& type() const
{
detail::variant::reflect visitor;
return this->apply_visitor(visitor);
@ -174,7 +174,7 @@ public: // visitor interfaces
`type_index` is just a typedef for `stl_type_index` or `ctti_type_index`.
Depending on the `typeid()` availability TypeIndex library will choose an optimal class for
`type_index`. In cases when at least basic support for `typeid()` is available `boost::typeind::stl_type_index`
`type_index`. In cases when at least basic support for `typeid()` is available `boost::typeindex::stl_type_index`
will be used.
`BOOST_TYPE_INDEX_REGISTER_CLASS` macro is a helper macro that places some virtual helper functions or
@ -243,8 +243,8 @@ so prefer using `stl_type_index` type when possible.
[section Code bloat]
Without RTTI TypeIndex library will switch from using `boost::typeind::stl_type_index` class to
`boost::typeind::ctti_type_index`. `boost::typeind::ctti_type_index` uses macro for getting full
Without RTTI TypeIndex library will switch from using `boost::typeindex::stl_type_index` class to
`boost::typeindex::ctti_type_index`. `boost::typeindex::ctti_type_index` uses macro for getting full
text representation of function name for each type that is passed to `type_id()` and
`type_id_with_cvr()` functions.
@ -283,7 +283,7 @@ feature request to add your compiler to supported compilers list. Include
Consider the following example:
With `BOOST_TYPE_INDEX_CTTI_BEGIN_SKIP` and `BOOST_TYPE_INDEX_CTTI_END_SKIP` set to `0`,
`boost::typeind::ctti_type_index::type_id<int>().raw_name()` returns
`boost::typeindex::ctti_type_index::type_id<int>().raw_name()` returns
"const char *__cdecl boost::detail::ctti<int>::n(void)". Then you shall set
`BOOST_TYPE_INDEX_CTTI_BEGIN_SKIP` to `sizeof("const char *__cdecl boost::detail::ctti<") - 1`
and `BOOST_TYPE_INDEX_CTTI_END_SKIP` to `sizeof(">::n(void)") - 1`.
@ -295,8 +295,8 @@ and `BOOST_TYPE_INDEX_CTTI_END_SKIP` to `sizeof(">::n(void)") - 1`.
Linking a binary from source files that were compiled with different RTTI flags is not a very good
idea and may lead to a lot of surprises. However if there is a very strong need, TypeIndex library
provides a solution for mixing sources: just define `BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY`
macro. This would lead to usage of same type_index class (`boost::typeind::ctti_type_index` or
`boost::typeind::stl_type_index`) all around the project.
macro. This would lead to usage of same type_index class (`boost::typeindex::ctti_type_index` or
`boost::typeindex::stl_type_index`) all around the project.
[note Do not forget to rebuild *all* the projects with `BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY` macro defined ]
@ -308,7 +308,7 @@ RTTI flags:
[table:diffs
[[RTTI on] [RTTI off]]
[[`boost::typeind::stl_type_index get_integer();`] [`boost::typeind::ctti_type_index get_integer();`]]
[[`boost::typeindex::stl_type_index get_integer();`] [`boost::typeindex::ctti_type_index get_integer();`]]
]
Such differences are usually not detected by linker and lead to errors at runtime.

5
examples/demangled_names.cpp
View File

@ -14,12 +14,11 @@
#include <boost/type_index.hpp>
#include <iostream>
namespace bti = boost::typeind;
template <class T>
void foo(T) {
std::cout << "\n Short name: " << boost::typeind::type_id<T>().raw_name();
std::cout << "\n Readable name: " << boost::typeind::type_id<T>().pretty_name();
std::cout << "\n Short name: " << boost::typeindex::type_id<T>().raw_name();
std::cout << "\n Readable name: " << boost::typeindex::type_id<T>().pretty_name();
}
struct user_defined_type{};

6
examples/exact_types_match.cpp
View File

@ -21,18 +21,18 @@
class type_erased_unary_function {
void* function_ptr_;
boost::typeind::type_index exact_param_t_;
boost::typeindex::type_index exact_param_t_;
public:
template <class ParamT>
type_erased_unary_function(void(*ptr)(ParamT))
: function_ptr_(reinterpret_cast<void*>(ptr)) // ptr - is a pointer to function returning `void` and accepting parameter of type `ParamT`
, exact_param_t_(boost::typeind::type_id_with_cvr<ParamT>())
, exact_param_t_(boost::typeindex::type_id_with_cvr<ParamT>())
{}
template <class ParamT>
void call(ParamT v) {
if (exact_param_t_ != boost::typeind::type_id_with_cvr<ParamT>()) {
if (exact_param_t_ != boost::typeindex::type_id_with_cvr<ParamT>()) {
throw std::runtime_error("Incorrect `ParamT`");
}

2
examples/inheritance.cpp
View File

@ -23,7 +23,7 @@ struct B: public A { BOOST_TYPE_INDEX_REGISTER_CLASS };
struct C: public B { BOOST_TYPE_INDEX_REGISTER_CLASS };
void print_real_type(const A& a) {
std::cout << boost::typeind::type_id_runtime(a).pretty_name() << '\n';
std::cout << boost::typeindex::type_id_runtime(a).pretty_name() << '\n';
}
int main() {

12
examples/registry.cpp
View File

@ -16,22 +16,22 @@
#include <cassert>
int main() {
boost::unordered_set<boost::typeind::type_index> types;
boost::unordered_set<boost::typeindex::type_index> types;
// Storing some `boost::type_info`s
types.insert(boost::typeind::type_id<int>());
types.insert(boost::typeind::type_id<float>());
types.insert(boost::typeindex::type_id<int>());
types.insert(boost::typeindex::type_id<float>());
// `types` variable contains two `boost::type_index`es:
assert(types.size() == 2);
// Const, volatile and reference will be striped from the type:
bool is_inserted = types.insert(boost::typeind::type_id<const int>()).second;
bool is_inserted = types.insert(boost::typeindex::type_id<const int>()).second;
assert(!is_inserted);
assert(types.erase(boost::typeind::type_id<float&>()) == 1);
assert(types.erase(boost::typeindex::type_id<float&>()) == 1);
// We have erased the `float` type, only `int` remains
assert(*types.begin() == boost::typeind::type_id<int>());
assert(*types.begin() == boost::typeindex::type_id<int>());
}
//] [/type_index_registry_example]

4
examples/user_defined_typeinfo.cpp
View File

@ -7,7 +7,7 @@
//[type_index_my_type_index_worldwide_macro
/*`
There is an easy way to force `boost::typeind::type_id` to use your own type_index class.
There is an easy way to force `boost::typeindex::type_id` to use your own type_index class.
All we need to do is just define `BOOST_TYPE_INDEX_USER_TYPEINDEX` to the full path to header file
of your type index class:
@ -56,7 +56,7 @@ int main() {
/*`
That's it! Now all TypeIndex global methods and typedefs will be using your class:
*/
boost::typeind::type_index worldwide = boost::typeind::type_id<my_classes>();
boost::typeindex::type_index worldwide = boost::typeindex::type_id<my_classes>();
assert(worldwide.pretty_name() == "my_classes");
assert(worldwide == my_type_index::type_id<my_classes>());
//][/type_index_my_type_index_worldwide_usage]

6
examples/user_defined_typeinfo.hpp
View File

@ -75,7 +75,7 @@ namespace my_namespace { namespace detail {
*/
namespace my_namespace {
class my_type_index: public boost::typeind::type_index_facade<my_type_index, detail::my_typeinfo> {
class my_type_index: public boost::typeindex::type_index_facade<my_type_index, detail::my_typeinfo> {
const detail::my_typeinfo* data_;
public:
@ -118,7 +118,7 @@ public:
} // namespace my_namespace
/*`
Note that we have used the boost::typeind::type_index_facade class as base.
Note that we have used the boost::typeindex::type_index_facade class as base.
That class took care about all the helper function and operators (comparison, hashing, ostreaming and others).
*/
@ -186,7 +186,7 @@ struct my_struct: public my_class {
You'll also need to add some typedefs and macro to your "user_defined_typeinfo.hpp" header file:
*/
#define BOOST_TYPE_INDEX_REGISTER_CLASS MY_TYPEINDEX_REGISTER_CLASS
namespace boost { namespace typeind {
namespace boost { namespace typeindex {
typedef my_namespace::my_type_index type_index;
}}
//] [/type_index_my_type_index_worldwide_typedefs]

26
include/boost/type_index.hpp
View File

@ -12,7 +12,7 @@
/// \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::typeind::type_index and boost::typeind::type_info.
/// as a boost::typeindex::type_index and boost::typeindex::type_info.
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
@ -33,33 +33,33 @@
# include <boost/type_index/ctti_register_class.hpp>
#endif
namespace boost { namespace typeind {
namespace boost { namespace typeindex {
#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
/// Depending on a compiler flags, optimal implementation of type_index will be used
/// as a default boost::typeind::type_index.
/// as a default boost::typeindex::type_index.
///
/// Could be a boost::typeind::stl_type_index, boost::typeind::ctti_type_index or
/// Could be a boost::typeindex::stl_type_index, boost::typeindex::ctti_type_index or
/// user defined type_index class.
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::typeind::stl_type_index type_index;
typedef boost::typeindex::stl_type_index type_index;
# ifdef BOOST_NO_RTTI
# define BOOST_TYPE_INDEX_REGISTER_CLASS BOOST_TYPE_INDEX_REGISTER_STL_CLASS
# else
# define BOOST_TYPE_INDEX_REGISTER_CLASS
# endif
#else
typedef boost::typeind::ctti_type_index type_index;
typedef boost::typeindex::ctti_type_index type_index;
# define BOOST_TYPE_INDEX_REGISTER_CLASS BOOST_TYPE_INDEX_REGISTER_CTTI_CLASS
#endif
/// Depending on a compiler flags, optimal implementation of type_info will be used
/// as a default boost::typeind::type_info.
/// as a default boost::typeindex::type_info.
///
/// Could be a std::type_info, boost::typeind::detail::ctti_data or
/// 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!
@ -102,7 +102,7 @@ typedef type_index::type_info_t type_info;
///
/// C c1;
/// A* pc1 = &c1;
/// assert(boost::typeind::type_id<C>() == boost::typeind::type_id_runtime(*pc1));
/// assert(boost::typeindex::type_id<C>() == boost::typeindex::type_id_runtime(*pc1));
/// \endcode
#define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
@ -126,7 +126,7 @@ typedef type_index::type_info_t type_info;
///
/// \tparam T Type for which type_index must be created.
/// \throw Nothing.
/// \return boost::typeind::type_index with information about the specified type T.
/// \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>();
@ -146,7 +146,7 @@ inline type_index type_id() BOOST_NOEXCEPT {
///
/// \tparam T Type for which type_index must be created.
/// \throw Nothing.
/// \return boost::typeind::type_index with information about the specified type T.
/// \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>();
@ -171,13 +171,13 @@ inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
///
/// \param runtime_val Varaible which runtime type must be returned.
/// \throw Nothing.
/// \return boost::typeind::type_index with information about the specified variable.
/// \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::typeind
}} // namespace boost::typeindex

8
include/boost/type_index/ctti_register_class.hpp
View File

@ -19,14 +19,14 @@
#include <boost/type_index/ctti_type_index.hpp>
namespace boost { namespace typeind { namespace detail {
namespace boost { namespace typeindex { namespace detail {
template <class T>
inline const ctti_data& ctti_construct_typeid_ref(const T*) BOOST_NOEXCEPT {
return ctti_construct<T>();
}
}}} // namespace boost::typeind::detail
}}} // namespace boost::typeindex::detail
/// \def BOOST_TYPE_INDEX_REGISTER_CTTI_CLASS
/// BOOST_TYPE_INDEX_REGISTER_CTTI_CLASS is used by BOOST_TYPE_INDEX_REGISTER_CLASS when RTTI is off
@ -35,8 +35,8 @@ inline const ctti_data& ctti_construct_typeid_ref(const T*) BOOST_NOEXCEPT {
/// BOOST_TYPE_INDEX_REGISTER_CTTI_CLASS macro expands to declaration and implementation of
/// `virtual const detail::ctti_data& type_id_runtime() const` method.
#define BOOST_TYPE_INDEX_REGISTER_CTTI_CLASS \
virtual const boost::typeind::detail::ctti_data& type_id_runtime() const BOOST_NOEXCEPT { \
return boost::typeind::detail::ctti_construct_typeid_ref(this); \
virtual const boost::typeindex::detail::ctti_data& type_id_runtime() const BOOST_NOEXCEPT { \
return boost::typeindex::detail::ctti_construct_typeid_ref(this); \
} \
/**/

8
include/boost/type_index/ctti_type_index.hpp
View File

@ -15,9 +15,9 @@
#endif
/// \file ctti_type_index.hpp
/// \brief Contains boost::typeind::ctti_type_index class.
/// \brief Contains boost::typeindex::ctti_type_index class.
///
/// boost::typeind::ctti_type_index class can be used as a drop-in replacement
/// boost::typeindex::ctti_type_index class can be used as a drop-in replacement
/// for std::type_index.
///
/// It is used in situations when typeid() method is not available or
@ -31,7 +31,7 @@
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace boost { namespace typeind {
namespace boost { namespace typeindex {
namespace detail {
@ -147,7 +147,7 @@ inline std::size_t ctti_type_index::hash_code() const BOOST_NOEXCEPT {
}
}} // namespace boost::typeind
}} // namespace boost::typeindex
#endif // BOOST_TYPE_INDEX_CTTI_TYPE_INDEX_HPP

10
include/boost/type_index/detail/compile_time_type_info.hpp
View File

@ -22,7 +22,7 @@
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
namespace boost { namespace typeind { namespace detail {
namespace boost { namespace typeindex { namespace detail {
#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
@ -89,7 +89,7 @@ namespace boost { namespace typeind { namespace detail {
BOOST_STATIC_CONSTANT(std::size_t, ctti_skip_size_at_end = 0); // skip nothing
#endif
}}} // namespace boost::typeind::detail
}}} // namespace boost::typeindex::detail
namespace boost { namespace detail {
@ -104,9 +104,9 @@ struct ctti {
/// Returns raw name. Must be as short, as possible, to avoid code bloat
static const char* n() BOOST_NOEXCEPT {
#if defined(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE)
return BOOST_TYPE_INDEX_FUNCTION_SIGNATURE + boost::typeind::detail::ctti_skip_size_at_begin;
return BOOST_TYPE_INDEX_FUNCTION_SIGNATURE + boost::typeindex::detail::ctti_skip_size_at_begin;
#elif defined(__FUNCSIG__)
return __FUNCSIG__ + boost::typeind::detail::ctti_skip_size_at_begin;
return __FUNCSIG__ + boost::typeindex::detail::ctti_skip_size_at_begin;
#elif defined(__PRETTY_FUNCTION__) \
|| defined(__GNUC__) \
|| (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) \
@ -114,7 +114,7 @@ struct ctti {
|| defined(__ghs__) \
|| defined(__DMC__)
return __PRETTY_FUNCTION__ + boost::typeind::detail::ctti_skip_size_at_begin;
return __PRETTY_FUNCTION__ + boost::typeindex::detail::ctti_skip_size_at_begin;
#else
BOOST_STATIC_ASSERT_MSG(
sizeof(T) && false,

8
include/boost/type_index/stl_register_class.hpp
View File

@ -19,14 +19,14 @@
#include <boost/type_index/stl_type_index.hpp>
namespace boost { namespace typeind { namespace detail {
namespace boost { namespace typeindex { namespace detail {
template <class T>
inline const stl_type_index::type_info_t& stl_construct_typeid_ref(const T*) BOOST_NOEXCEPT {
return typeid(T);
}
}}} // namespace boost::typeind::detail
}}} // namespace boost::typeindex::detail
/// \def BOOST_TYPE_INDEX_REGISTER_STL_CLASS
@ -36,8 +36,8 @@ inline const stl_type_index::type_info_t& stl_construct_typeid_ref(const T*) BOO
/// BOOST_TYPE_INDEX_REGISTER_STL_CLASS macro expands to declaration and implementation of
/// `virtual const std::type_info& type_id_runtime() const` method.
#define BOOST_TYPE_INDEX_REGISTER_STL_CLASS \
virtual const boost::typeind::stl_type_index::type_info_t& type_id_runtime() const BOOST_NOEXCEPT { \
return boost::typeind::detail::stl_construct_typeid_ref(this); \
virtual const boost::typeindex::stl_type_index::type_info_t& type_id_runtime() const BOOST_NOEXCEPT { \
return boost::typeindex::detail::stl_construct_typeid_ref(this); \
} \
/**/

14
include/boost/type_index/stl_type_index.hpp
View File

@ -15,14 +15,14 @@
#endif
/// \file stl_type_index.hpp
/// \brief Contains boost::typeind::stl_type_index class.
/// \brief Contains boost::typeindex::stl_type_index class.
///
/// boost::typeind::stl_type_index class can be used as a drop-in replacement
/// boost::typeindex::stl_type_index class can be used as a drop-in replacement
/// for std::type_index.
///
/// It is used in situations when RTTI is enabled or typeid() method is available.
/// When typeid() is disabled or BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY macro
/// is defined boost::typeind::ctti is usually used instead of boost::typeind::stl_type_index.
/// is defined boost::typeindex::ctti is usually used instead of boost::typeindex::stl_type_index.
#include <boost/type_index/type_index_facade.hpp>
@ -58,7 +58,7 @@
# include <boost/type_traits/is_arithmetic.hpp>
#endif
namespace boost { namespace typeind {
namespace boost { namespace typeindex {
/// \class stl_type_index
/// This class is a wrapper around std::type_info, that workarounds issues and provides
@ -150,12 +150,12 @@ inline std::string stl_type_index::pretty_name() const {
free(demang);
#endif
std::string::size_type pos = ret.find("boost::typeind::detail::cvr_saver<");
std::string::size_type pos = ret.find("boost::typeindex::detail::cvr_saver<");
if (pos == std::string::npos) {
return ret;
}
pos += sizeof("boost::typeind::detail::cvr_saver<") - 1;
pos += sizeof("boost::typeindex::detail::cvr_saver<") - 1;
while (ret[pos] == ' ') {
++ pos;
}
@ -255,7 +255,7 @@ inline stl_type_index stl_type_index::type_id_runtime(const T& value) BOOST_NOEX
#endif
}
}} // namespace boost::typeind
}} // namespace boost::typeindex
#endif // BOOST_TYPE_INDEX_STL_TYPE_INDEX_HPP

10
include/boost/type_index/type_index_facade.hpp
View File

@ -27,7 +27,7 @@
#endif
#endif
namespace boost { namespace typeind {
namespace boost { namespace typeindex {
/// \class type_index_facade
///
@ -110,7 +110,7 @@ public:
#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
protected:
/// This is a factory method that is used to create instances of Derived classes.
/// boost::typeind::type_id() will call this method, if Derived has same type as boost::typeind::type_index.
/// 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.
@ -120,7 +120,7 @@ protected:
static Derived type_id() BOOST_NOEXCEPT;
/// This is a factory method that is used to create instances of Derived classes.
/// boost::typeind::type_id_with_cvr() will call this method, if Derived has same type as boost::typeind::type_index.
/// 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.
@ -130,7 +130,7 @@ protected:
static Derived type_id_with_cvr() BOOST_NOEXCEPT;
/// This is a factory method that is used to create instances of Derived classes.
/// boost::typeind::type_id_runtime(const T&) will call this method, if Derived has same type as boost::typeind::type_index.
/// 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.
@ -283,7 +283,7 @@ inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) B
return static_cast<Derived const&>(lhs).hash_code();
}
}} // namespace boost::typeind
}} // namespace boost::typeindex
#endif // BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP

18
test/test_lib.cpp
View File

@ -7,25 +7,25 @@ namespace user_defined_namespace {
namespace test_lib {
boost::typeind::type_index get_integer() {
return boost::typeind::type_id<int>();
boost::typeindex::type_index get_integer() {
return boost::typeindex::type_id<int>();
}
boost::typeind::type_index get_user_defined_class() {
return boost::typeind::type_id<user_defined_namespace::user_defined>();
boost::typeindex::type_index get_user_defined_class() {
return boost::typeindex::type_id<user_defined_namespace::user_defined>();
}
boost::typeind::type_index get_const_integer() {
return boost::typeind::type_id_with_cvr<const int>();
boost::typeindex::type_index get_const_integer() {
return boost::typeindex::type_id_with_cvr<const int>();
}
boost::typeind::type_index get_const_user_defined_class() {
return boost::typeind::type_id_with_cvr<const user_defined_namespace::user_defined>();
boost::typeindex::type_index get_const_user_defined_class() {
return boost::typeindex::type_id_with_cvr<const user_defined_namespace::user_defined>();
}
// Just do nothing
void accept_typeindex(const boost::typeind::type_index&) {}
void accept_typeindex(const boost::typeindex::type_index&) {}
}

10
test/test_lib.hpp
View File

@ -25,14 +25,14 @@
namespace test_lib {
TEST_LIB_DECL boost::typeind::type_index get_integer();
TEST_LIB_DECL boost::typeind::type_index get_user_defined_class();
TEST_LIB_DECL boost::typeindex::type_index get_integer();
TEST_LIB_DECL boost::typeindex::type_index get_user_defined_class();
TEST_LIB_DECL boost::typeind::type_index get_const_integer();
TEST_LIB_DECL boost::typeind::type_index get_const_user_defined_class();
TEST_LIB_DECL boost::typeindex::type_index get_const_integer();
TEST_LIB_DECL boost::typeindex::type_index get_const_user_defined_class();
// This is required for checking RTTI on/off linkage
TEST_LIB_DECL void accept_typeindex(const boost::typeind::type_index&);
TEST_LIB_DECL void accept_typeindex(const boost::typeindex::type_index&);
}

12
test/testing_crossmodule.cpp
View File

@ -17,8 +17,8 @@ namespace user_defined_namespace {
BOOST_AUTO_TEST_CASE(comparing_types_between_modules)
{
boost::typeind::type_index t_const_int = boost::typeind::type_id_with_cvr<const int>();
boost::typeind::type_index t_int = boost::typeind::type_id<int>();
boost::typeindex::type_index t_const_int = boost::typeindex::type_id_with_cvr<const int>();
boost::typeindex::type_index t_int = boost::typeindex::type_id<int>();
BOOST_CHECK_EQUAL(t_int, test_lib::get_integer());
BOOST_CHECK_EQUAL(t_const_int, test_lib::get_const_integer());
@ -26,10 +26,10 @@ BOOST_AUTO_TEST_CASE(comparing_types_between_modules)
BOOST_CHECK_NE(t_int, test_lib::get_const_integer());
boost::typeind::type_index t_const_userdef
= boost::typeind::type_id_with_cvr<const user_defined_namespace::user_defined>();
boost::typeind::type_index t_userdef
= boost::typeind::type_id<user_defined_namespace::user_defined>();
boost::typeindex::type_index t_const_userdef
= boost::typeindex::type_id_with_cvr<const user_defined_namespace::user_defined>();
boost::typeindex::type_index t_userdef
= boost::typeindex::type_id<user_defined_namespace::user_defined>();
BOOST_CHECK_EQUAL(t_userdef, test_lib::get_user_defined_class());
BOOST_CHECK_EQUAL(t_const_userdef, test_lib::get_const_user_defined_class());

56
test/type_index_test.cpp
View File

@ -25,7 +25,7 @@ namespace my_namespace2 {
BOOST_AUTO_TEST_CASE(names_matches_type_id)
{
using namespace boost::typeind;
using namespace boost::typeindex;
BOOST_CHECK_EQUAL(type_id<int>().pretty_name(), "int");
BOOST_CHECK_EQUAL(type_id<double>().pretty_name(), "double");
@ -37,7 +37,7 @@ BOOST_AUTO_TEST_CASE(names_matches_type_id)
BOOST_AUTO_TEST_CASE(default_construction)
{
using namespace boost::typeind;
using namespace boost::typeindex;
type_index ti1, ti2;
BOOST_CHECK_EQUAL(ti1, ti2);
BOOST_CHECK_EQUAL(type_id<void>(), ti1);
@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE(default_construction)
BOOST_AUTO_TEST_CASE(copy_construction)
{
using namespace boost::typeind;
using namespace boost::typeindex;
type_index ti1, ti2 = type_id<int>();
BOOST_CHECK_NE(ti1, ti2);
ti1 = ti2;
@ -61,7 +61,7 @@ BOOST_AUTO_TEST_CASE(copy_construction)
BOOST_AUTO_TEST_CASE(comparators_type_id)
{
using namespace boost::typeind;
using namespace boost::typeindex;
type_index t_int = type_id<int>();
type_index t_double = type_id<double>();
@ -80,7 +80,7 @@ BOOST_AUTO_TEST_CASE(comparators_type_id)
BOOST_AUTO_TEST_CASE(hash_code_type_id)
{
using namespace boost::typeind;
using namespace boost::typeindex;
std::size_t t_int1 = type_id<int>().hash_code();
std::size_t t_double1 = type_id<double>().hash_code();
@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE(hash_code_type_id)
template <class T1, class T2>
static void test_with_modofiers() {
using namespace boost::typeind;
using namespace boost::typeindex;
type_index t1 = type_id_with_cvr<T1>();
type_index t2 = type_id_with_cvr<T2>();
@ -182,7 +182,7 @@ BOOST_AUTO_TEST_CASE(type_id_storing_modifiers)
template <class T>
static void test_storing_nonstoring_modifiers_templ() {
using namespace boost::typeind;
using namespace boost::typeindex;
type_index t1 = type_id_with_cvr<T>();
type_index t2 = type_id<T>();
@ -203,15 +203,15 @@ BOOST_AUTO_TEST_CASE(type_id_storing_modifiers_vs_nonstoring)
test_storing_nonstoring_modifiers_templ<my_namespace1::my_class>();
test_storing_nonstoring_modifiers_templ<my_namespace2::my_class>();
boost::typeind::type_index t1 = boost::typeind::type_id_with_cvr<const int>();
boost::typeind::type_index t2 = boost::typeind::type_id<int>();
boost::typeindex::type_index t1 = boost::typeindex::type_id_with_cvr<const int>();
boost::typeindex::type_index t2 = boost::typeindex::type_id<int>();
BOOST_CHECK_NE(t2, t1);
BOOST_CHECK(t1.pretty_name() == "const int" || t1.pretty_name() == "int const");
}
BOOST_AUTO_TEST_CASE(type_index_stream_operator_via_lexical_cast_testing)
{
using namespace boost::typeind;
using namespace boost::typeindex;
std::string s_int2 = boost::lexical_cast<std::string>(type_id<int>());
BOOST_CHECK_EQUAL(s_int2, "int");
@ -222,7 +222,7 @@ BOOST_AUTO_TEST_CASE(type_index_stream_operator_via_lexical_cast_testing)
BOOST_AUTO_TEST_CASE(type_index_stripping_cvr_test)
{
using namespace boost::typeind;
using namespace boost::typeindex;
BOOST_CHECK_EQUAL(type_id<int>(), type_id<const int>());
BOOST_CHECK_EQUAL(type_id<int>(), type_id<const volatile int>());
@ -245,7 +245,7 @@ BOOST_AUTO_TEST_CASE(type_index_stripping_cvr_test)
BOOST_AUTO_TEST_CASE(type_index_user_defined_class_test)
{
using namespace boost::typeind;
using namespace boost::typeindex;
BOOST_CHECK_EQUAL(type_id<my_namespace1::my_class>(), type_id<my_namespace1::my_class>());
BOOST_CHECK_EQUAL(type_id<my_namespace2::my_class>(), type_id<my_namespace2::my_class>());
@ -297,28 +297,28 @@ BOOST_AUTO_TEST_CASE(comparators_type_id_runtime)
BOOST_CHECK(typeid(&rc1) == typeid(pb1));
BOOST_CHECK(typeid(&rb1) == typeid(pc1));
#else
BOOST_CHECK(boost::typeind::type_index(pc1->type_id_runtime()).raw_name());
BOOST_CHECK(boost::typeindex::type_index(pc1->type_id_runtime()).raw_name());
#endif
BOOST_CHECK_EQUAL(boost::typeind::type_id_runtime(rc1), boost::typeind::type_id_runtime(*pc1));
BOOST_CHECK_EQUAL(boost::typeind::type_id<C>(), boost::typeind::type_id_runtime(*pc1));
BOOST_CHECK_EQUAL(boost::typeind::type_id_runtime(rb1), boost::typeind::type_id_runtime(*pb1));
BOOST_CHECK_EQUAL(boost::typeind::type_id<B>(), boost::typeind::type_id_runtime(*pb1));
BOOST_CHECK_EQUAL(boost::typeindex::type_id_runtime(rc1), boost::typeindex::type_id_runtime(*pc1));
BOOST_CHECK_EQUAL(boost::typeindex::type_id<C>(), boost::typeindex::type_id_runtime(*pc1));
BOOST_CHECK_EQUAL(boost::typeindex::type_id_runtime(rb1), boost::typeindex::type_id_runtime(*pb1));
BOOST_CHECK_EQUAL(boost::typeindex::type_id<B>(), boost::typeindex::type_id_runtime(*pb1));
BOOST_CHECK_NE(boost::typeind::type_id_runtime(rc1), boost::typeind::type_id_runtime(*pb1));
BOOST_CHECK_NE(boost::typeind::type_id_runtime(rb1), boost::typeind::type_id_runtime(*pc1));
BOOST_CHECK_NE(boost::typeindex::type_id_runtime(rc1), boost::typeindex::type_id_runtime(*pb1));
BOOST_CHECK_NE(boost::typeindex::type_id_runtime(rb1), boost::typeindex::type_id_runtime(*pc1));
#ifndef BOOST_NO_RTTI
BOOST_CHECK_EQUAL(boost::typeind::type_id_runtime(&rc1), boost::typeind::type_id_runtime(pb1));
BOOST_CHECK_EQUAL(boost::typeind::type_id_runtime(&rb1), boost::typeind::type_id_runtime(pc1));
BOOST_CHECK_EQUAL(boost::typeindex::type_id_runtime(&rc1), boost::typeindex::type_id_runtime(pb1));
BOOST_CHECK_EQUAL(boost::typeindex::type_id_runtime(&rb1), boost::typeindex::type_id_runtime(pc1));
BOOST_CHECK(boost::typeind::type_id_runtime(rc1) == typeid(*pc1));
BOOST_CHECK(boost::typeind::type_id_runtime(rb1) == typeid(*pb1));
BOOST_CHECK(boost::typeindex::type_id_runtime(rc1) == typeid(*pc1));
BOOST_CHECK(boost::typeindex::type_id_runtime(rb1) == typeid(*pb1));
BOOST_CHECK(boost::typeind::type_id_runtime(rc1) != typeid(*pb1));
BOOST_CHECK(boost::typeind::type_id_runtime(rb1) != typeid(*pc1));
BOOST_CHECK(boost::typeind::type_id_runtime(&rc1) == typeid(pb1));
BOOST_CHECK(boost::typeind::type_id_runtime(&rb1) == typeid(pc1));
BOOST_CHECK(boost::typeindex::type_id_runtime(rc1) != typeid(*pb1));
BOOST_CHECK(boost::typeindex::type_id_runtime(rb1) != typeid(*pc1));
BOOST_CHECK(boost::typeindex::type_id_runtime(&rc1) == typeid(pb1));
BOOST_CHECK(boost::typeindex::type_id_runtime(&rb1) == typeid(pc1));
#endif
}
@ -327,7 +327,7 @@ BOOST_AUTO_TEST_CASE(comparators_type_id_runtime)
BOOST_AUTO_TEST_CASE(comparators_type_id_vs_type_info)
{
using namespace boost::typeind;
using namespace boost::typeindex;
type_index t_int = type_id<int>();
BOOST_CHECK(t_int == typeid(int));

4
test/type_index_test_ctti_alignment.cpp
View File

@ -10,8 +10,8 @@
int main() {
BOOST_STATIC_ASSERT_MSG(
boost::alignment_of<boost::typeind::detail::ctti_data>::value == boost::alignment_of<char>::value,
"Alignments of boost::typeind::detail::ctti_data and char differ. "
boost::alignment_of<boost::typeindex::detail::ctti_data>::value == boost::alignment_of<char>::value,
"Alignments of boost::typeindex::detail::ctti_data and char differ. "
"It is unsafe to reinterpret_cast between them."
);
}

2
test/type_index_test_ctti_construct_fail.cpp
View File

@ -8,7 +8,7 @@
#include <boost/type_index/ctti_type_index.hpp>
int main() {
using namespace boost::typeind;
using namespace boost::typeindex;
ctti_type_index::type_info_t t;
(void)t;
}

2
test/type_index_test_ctti_copy_fail.cpp
View File

@ -8,7 +8,7 @@
#include <boost/type_index/ctti_type_index.hpp>
int main() {
using namespace boost::typeind;
using namespace boost::typeindex;
ctti_type_index::type_info_t t = ctti_type_index::type_id<int>().type_info();
(void)t;
}