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

First version.

Browse Source
This commit is contained in:
Chris Glover 2016-07-15 08:49:54 -04:00
parent 31ec1d2524
commit b230140529
4 changed files with 241 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/exact_types_match.cpp
View File

@ -17,6 +17,8 @@
#include <boost/type_index.hpp>
#include <iostream>
#include <stdexcept>
#include <cstdlib>
//<-
// Making `#include <cassert>` visible in docs, while actually using hand-made check
// instead of `assert`. This is required to verify correct behavior even if NDEBUG

119
include/boost/type_index/runtime_cast.hpp Normal file
View File

@ -0,0 +1,119 @@
//
// Copyright (c) CHris Glover, 2016.
//
//
// 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_RUNTIME_CAST_HPP
#define BOOST_TYPE_INDEX_RUNTIME_CAST_HPP
/// \file runtime_cast.hpp
/// \brief Contains boost::typeindex::ctti_type_index class that is constexpr if C++14 constexpr is supported by compiler.
///
/// boost::typeindex::runtime_cast class can be used as a replacement
/// for dynamic_cast on platforms where dynamic_cast is not available
/// or undesirable at a global level.
#include <boost/type_index.hpp>
#include <type_traits>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
namespace boost { namespace typeindex {
namespace detail {
template<class Desired, class... BaseList>
struct find_type;
template<class Desired>
struct find_type<Desired> {
void* operator()(Desired* p, type_index const& idx) const BOOST_NOEXCEPT {
if(idx == boost::typeindex::type_id<Desired>())
return p;
return nullptr;
}
};
template<class Desired, class... BaseList>
struct find_type {
template<class T>
Desired* check_results(T* t) const BOOST_NOEXCEPT {
if(t)
return static_cast<Desired*>(t);
return nullptr;
}
template<class T, class... Rest>
Desired* check_results(T* t, Rest... rest) const BOOST_NOEXCEPT {
if(t)
return static_cast<Desired*>(t);
return check_results(rest...);
}
template<class T>
void* operator()(T* p, type_index const& idx) const BOOST_NOEXCEPT {
if(auto result = check_results(p->BaseList::boost_type_index_find_instance_(idx)...)) {
return result;
}
else {
return find_type<BaseList...>()(p, idx);
}
}
};
template<typename T, typename U>
T* runtime_cast_impl(U* u, std::true_type) {
return u;
}
template<typename T, typename U>
T const* runtime_cast_impl(U const* u, std::true_type) {
return u;
}
template<typename T, typename U>
T* runtime_cast_impl(U* u, std::false_type) {
return static_cast<T*>(
u->boost_type_index_find_instance_(boost::typeindex::type_id<T>())
);
}
template<typename T, typename U>
T const* runtime_cast_impl(U const* u, std::false_type) {
return static_cast<T const*>(
const_cast<U*>(u)->boost_type_index_find_instance_(boost::typeindex::type_id<T>())
);
}
} // namespace detail
#define BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI \
virtual void* boost_type_index_find_instance_(boost::typeindex::type_index const& idx) BOOST_NOEXCEPT { \
return boost::typeindex::detail::find_type<std::decay<decltype(*this)>::type>()(this, idx); \
}
#define BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI_BASES(...) \
virtual void* boost_type_index_find_instance_(boost::typeindex::type_index const& idx) BOOST_NOEXCEPT { \
if(auto ret = boost::typeindex::detail::find_type<std::decay<decltype(*this)>::type>()(this, idx)) \
return ret; \
return boost::typeindex::detail::find_type<std::decay<decltype(*this)>::type, __VA_ARGS__>()(this, idx);\
}
template<typename T, typename U>
T* runtime_cast(U* u) {
return detail::runtime_cast_impl<T>(u, std::is_same<T, U>());
}
template<typename T, typename U>
T const* runtime_cast(U const* u) {
return detail::runtime_cast_impl<T>(u, std::is_same<T, U>());
}
}} // namespace boost::typeindex
#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_HPP

1
test/Jamfile.v2
View File

@ -40,6 +40,7 @@ exe testing_crossmodule_anonymous_no_rtti : testing_crossmodule_anonymous.cpp te
test-suite type_index
:
[ run type_index_test.cpp ]
[ run runtime_cast_test.cpp ]
[ run type_index_constexpr_test.cpp ]
[ run type_index_test.cpp : : : <rtti>off $(norttidefines) : type_index_test_no_rtti ]
[ run ctti_print_name.cpp : : : <test-info>always_show_run_output ]

119
test/runtime_cast_test.cpp Normal file
View File

@ -0,0 +1,119 @@
//
// Copyright Chris Glover, 2016.
//
// 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)
#include <boost/type_index/runtime_cast.hpp>
#include <boost/core/lightweight_test.hpp>
// Classes include a member variable "name" with the
// name of the class hard coded so we can be sure that
// the pointer offsets are all working, since we're doing
// a cast from void* at some point.
#define IMPLEMENT_CLASS(type_name) \
type_name() : name( #type_name ) {} \
std::string name;
struct base {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI
IMPLEMENT_CLASS(base)
};
struct single_derived : base {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI_BASES(base)
IMPLEMENT_CLASS(single_derived)
};
struct base1 {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI
IMPLEMENT_CLASS(base1)
};
struct base2 {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI
IMPLEMENT_CLASS(base2)
};
struct multiple_derived : base1, base2 {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI_BASES(base1, base2)
IMPLEMENT_CLASS(multiple_derived)
};
struct baseV1 : virtual base {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI_BASES(base)
IMPLEMENT_CLASS(baseV1)
};
struct baseV2 : virtual base {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI_BASES(base)
IMPLEMENT_CLASS(baseV2)
};
struct multiple_virtual_derived : baseV1, baseV2 {
BOOST_TYPE_INDEX_REGISTER_CLASS_RTTI_BASES(baseV1, baseV2)
IMPLEMENT_CLASS(multiple_virtual_derived)
};
void no_base()
{
using namespace boost::typeindex;
base b;
base* b2 = runtime_cast<base>(&b);
BOOST_TEST_NE(b2, (base*)nullptr);
BOOST_TEST_EQ(b2->name, "base");
}
void single_base()
{
using namespace boost::typeindex;
single_derived d;
base* b = &d;
single_derived* d2 = runtime_cast<single_derived>(b);
BOOST_TEST_NE(d2, (single_derived*)nullptr);
BOOST_TEST_EQ(d2->name, "single_derived");
}
void multiple_base()
{
using namespace boost::typeindex;
multiple_derived d;
base1* b1 = &d;
multiple_derived* d2 = runtime_cast<multiple_derived>(b1);
BOOST_TEST_NE(d2, (multiple_derived*)nullptr);
BOOST_TEST_EQ(d2->name, "multiple_derived");
base2* b2 = runtime_cast<base2>(b1);
BOOST_TEST_NE(b2, (base2*)nullptr);
BOOST_TEST_EQ(b2->name, "base2");
}
void virtual_base()
{
using namespace boost::typeindex;
multiple_virtual_derived d;
base* b = &d;
multiple_virtual_derived* d2 = runtime_cast<multiple_virtual_derived>(b);
baseV1* bv1 = runtime_cast<baseV1>(b);
baseV2* bv2 = runtime_cast<baseV2>(b);
BOOST_TEST_NE(d2, (multiple_virtual_derived*)nullptr);
BOOST_TEST_EQ(d2->name, "multiple_virtual_derived");
BOOST_TEST_NE(bv1, (baseV1*)nullptr);
BOOST_TEST_EQ(bv1->name, "baseV1");
BOOST_TEST_NE(bv2, (baseV2*)nullptr);
BOOST_TEST_EQ(bv2->name, "baseV2");
}
int main() {
no_base();
single_derived();
return boost::report_errors();
}