boost/type_erasure/register_binding.hpp
// Boost.TypeErasure library // // Copyright 2015 Steven Watanabe // // 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) // // $Id$ #ifndef BOOST_TYPE_ERASURE_REGISTER_BINDING_HPP_INCLUDED #define BOOST_TYPE_ERASURE_REGISTER_BINDING_HPP_INCLUDED #include <boost/type_erasure/detail/check_map.hpp> #include <boost/type_erasure/detail/get_placeholders.hpp> #include <boost/type_erasure/detail/rebind_placeholders.hpp> #include <boost/type_erasure/detail/normalize.hpp> #include <boost/type_erasure/detail/adapt_to_vtable.hpp> #include <boost/type_erasure/detail/auto_link.hpp> #include <boost/type_erasure/static_binding.hpp> #include <boost/mpl/transform.hpp> #include <boost/mpl/remove_if.hpp> #include <boost/mpl/fold.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/has_key.hpp> #include <boost/mpl/insert.hpp> #include <boost/mpl/front.hpp> #include <boost/mpl/size.hpp> #include <boost/mpl/equal_to.hpp> #include <boost/mpl/or.hpp> #include <boost/mpl/set.hpp> #include <boost/mpl/map.hpp> #include <boost/mpl/vector.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/pair.hpp> #include <boost/mpl/back_inserter.hpp> #include <boost/mpl/for_each.hpp> #include <vector> #include <typeinfo> namespace boost { namespace type_erasure { namespace detail { typedef std::vector<const std::type_info*> key_type; typedef void (*value_type)(); BOOST_TYPE_ERASURE_DECL void register_function_impl(const key_type& key, value_type fn); BOOST_TYPE_ERASURE_DECL value_type lookup_function_impl(const key_type& key); template<class Map> struct append_to_key_static { append_to_key_static(key_type* k) : key(k) {} template<class P> void operator()(P) { #ifndef BOOST_TYPE_ERASURE_USE_MP11 key->push_back(&typeid(typename ::boost::mpl::at<Map, P>::type)); #else key->push_back(&typeid(::boost::mp11::mp_second< ::boost::mp11::mp_map_find<Map, P> >)); #endif } key_type* key; }; // This placeholder exists solely to create a normalized // representation of a primitive concept. For the moment // I'm going to be conservative and require a bijection // between the original placeholders and the normalized // placeholders. It should be safe to map everything // to a single placeholder, though, as long as the // key includes every instance of each placeholder // as a separate element. i.e. we should be able to // turn addable<_a, _b> into addable<_, _> and // addable<_a, _a> into addable<_, _> as well if we always // add typeids for both arguments to the search key. template<int N> struct _ : ::boost::type_erasure::placeholder {}; struct counting_map_appender { template<class State, class Key> struct apply { typedef typename ::boost::mpl::insert< State, ::boost::mpl::pair< Key, ::boost::type_erasure::detail::_< ::boost::mpl::size<State>::value > > >::type type; }; }; template<class Map> struct register_function { template<class F> void operator()(F) { key_type key; #ifndef BOOST_TYPE_ERASURE_USE_MP11 typedef typename ::boost::type_erasure::detail::get_placeholders<F, ::boost::mpl::set0<> >::type placeholders; #else typedef typename ::boost::type_erasure::detail::get_placeholders<F, ::boost::mp11::mp_list<> >::type placeholders; #endif typedef typename ::boost::mpl::fold< placeholders, ::boost::mpl::map0<>, ::boost::type_erasure::detail::counting_map_appender >::type placeholder_map; key.push_back(&typeid(typename ::boost::type_erasure::detail::rebind_placeholders<F, placeholder_map>::type)); ::boost::mpl::for_each<placeholders>(append_to_key_static<Map>(&key)); value_type fn = reinterpret_cast<value_type>(&::boost::type_erasure::detail::rebind_placeholders<F, Map>::type::value); ::boost::type_erasure::detail::register_function_impl(key, fn); } }; } /** * Registers a model of a concept to allow downcasting @ref any * via \dynamic_any_cast. */ template<class Concept, class Map> void register_binding(const static_binding<Map>&) { typedef typename ::boost::type_erasure::detail::normalize_concept< Concept >::type normalized; typedef typename ::boost::mpl::transform<normalized, ::boost::type_erasure::detail::maybe_adapt_to_vtable< ::boost::mpl::_1> >::type actual_concept; typedef typename ::boost::type_erasure::detail::get_placeholder_normalization_map< Concept >::type placeholder_subs; typedef typename ::boost::type_erasure::detail::add_deductions<Map, placeholder_subs>::type actual_map; ::boost::mpl::for_each<actual_concept>(::boost::type_erasure::detail::register_function<actual_map>()); } /** * \overload */ template<class Concept, class T> void register_binding() { // Find all placeholders typedef typename ::boost::type_erasure::detail::normalize_concept_impl<Concept>::type normalized; typedef typename normalized::first basic; typedef typename ::boost::mpl::fold< basic, #ifndef BOOST_TYPE_ERASURE_USE_MP11 ::boost::mpl::set0<>, #else ::boost::mp11::mp_list<>, #endif ::boost::type_erasure::detail::get_placeholders< ::boost::mpl::_2, ::boost::mpl::_1> >::type all_placeholders; // remove deduced placeholders typedef typename ::boost::mpl::fold< typename normalized::second, ::boost::mpl::set0<>, ::boost::mpl::insert< ::boost::mpl::_1, ::boost::mpl::second< ::boost::mpl::_2> > >::type xtra_deduced; typedef typename ::boost::mpl::remove_if< all_placeholders, ::boost::mpl::or_< ::boost::type_erasure::detail::is_deduced< ::boost::mpl::_1>, ::boost::mpl::has_key<xtra_deduced, ::boost::mpl::_1> >, ::boost::mpl::back_inserter< ::boost::mpl::vector0<> > >::type unknown_placeholders; // Bind the single remaining placeholder to T BOOST_MPL_ASSERT((boost::mpl::equal_to<boost::mpl::size<unknown_placeholders>, boost::mpl::int_<1> >)); register_binding<Concept>(::boost::type_erasure::make_binding< ::boost::mpl::map< ::boost::mpl::pair<typename ::boost::mpl::front<unknown_placeholders>::type, T> > >()); } } } #endif