diff options
Diffstat (limited to 'boost/log/utility/type_dispatch/static_type_dispatcher.hpp')
| -rw-r--r-- | boost/log/utility/type_dispatch/static_type_dispatcher.hpp | 319 |
1 files changed, 319 insertions, 0 deletions
diff --git a/boost/log/utility/type_dispatch/static_type_dispatcher.hpp b/boost/log/utility/type_dispatch/static_type_dispatcher.hpp new file mode 100644 index 0000000000..73cf21b243 --- /dev/null +++ b/boost/log/utility/type_dispatch/static_type_dispatcher.hpp @@ -0,0 +1,319 @@ +/* + * Copyright Andrey Semashev 2007 - 2014. + * 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) + */ +/*! + * \file static_type_dispatcher.hpp + * \author Andrey Semashev + * \date 15.04.2007 + * + * The header contains implementation of a compile-time type dispatcher. + */ + +#ifndef BOOST_LOG_STATIC_TYPE_DISPATCHER_HPP_INCLUDED_ +#define BOOST_LOG_STATIC_TYPE_DISPATCHER_HPP_INCLUDED_ + +#include <cstddef> +#include <utility> +#include <iterator> +#include <algorithm> +#include <boost/array.hpp> +#include <boost/static_assert.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/size.hpp> +#include <boost/mpl/begin.hpp> +#include <boost/mpl/end.hpp> +#include <boost/mpl/deref.hpp> +#include <boost/mpl/next.hpp> +#include <boost/mpl/is_sequence.hpp> +#include <boost/utility/addressof.hpp> +#include <boost/log/detail/config.hpp> +#include <boost/log/detail/visible_type.hpp> +#include <boost/log/utility/once_block.hpp> +#include <boost/log/utility/type_info_wrapper.hpp> +#include <boost/log/utility/type_dispatch/type_dispatcher.hpp> +#include <boost/log/detail/header.hpp> + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +BOOST_LOG_OPEN_NAMESPACE + +namespace aux { + +//! Ordering predicate for type dispatching map +struct dispatching_map_order +{ + typedef bool result_type; + typedef std::pair< type_info_wrapper, void* > first_argument_type, second_argument_type; + result_type operator() (first_argument_type const& left, second_argument_type const& right) const + { + return (left.first < right.first); + } +}; + +//! Dispatching map filler +template< typename VisitorT > +struct dispatching_map_initializer +{ + template< typename IteratorT > + static BOOST_FORCEINLINE void init(IteratorT*, IteratorT*, std::pair< type_info_wrapper, void* >*) + { + } + + template< typename BeginIteratorT, typename EndIteratorT > + static BOOST_FORCEINLINE void init(BeginIteratorT*, EndIteratorT* end, std::pair< type_info_wrapper, void* >* p) + { + typedef typename mpl::deref< BeginIteratorT >::type type; + do_init(static_cast< visible_type< type >* >(0), p); + + typedef typename mpl::next< BeginIteratorT >::type next_iterator_type; + init(static_cast< next_iterator_type* >(0), end, p + 1); + } + +private: + template< typename T > + static BOOST_FORCEINLINE void do_init(visible_type< T >*, std::pair< type_info_wrapper, void* >* p) + { + p->first = typeid(visible_type< T >); + + typedef void (*trampoline_t)(void*, T const&); + BOOST_STATIC_ASSERT_MSG(sizeof(trampoline_t) == sizeof(void*), "Boost.Log: Unsupported platform, the size of a function pointer differs from the size of a pointer"); + union + { + void* as_pvoid; + trampoline_t as_trampoline; + } + caster; + caster.as_trampoline = &type_dispatcher::callback_base::trampoline< VisitorT, T >; + p->second = caster.as_pvoid; + } +}; + +//! A base class for a dispatcher that supports a sequence of types +class type_sequence_dispatcher_base : + public type_dispatcher +{ +private: + //! Dispatching map element type + typedef std::pair< type_info_wrapper, void* > dispatching_map_element_type; + +private: + //! Dispatching map + const dispatching_map_element_type* m_dispatching_map_begin; + //! Dispatching map size + std::size_t m_dispatching_map_size; + //! Pointer to the receiver function + void* m_visitor; + +protected: + //! Initializing constructor + type_sequence_dispatcher_base(const dispatching_map_element_type* disp_map, std::size_t disp_map_size, void* visitor) BOOST_NOEXCEPT : + type_dispatcher(&type_sequence_dispatcher_base::get_callback), + m_dispatching_map_begin(disp_map), + m_dispatching_map_size(disp_map_size), + m_visitor(visitor) + { + } + +private: + //! The get_callback method implementation + static callback_base get_callback(type_dispatcher* p, std::type_info const& type) + { + type_sequence_dispatcher_base* const self = static_cast< type_sequence_dispatcher_base* >(p); + type_info_wrapper wrapper(type); + const dispatching_map_element_type* begin = self->m_dispatching_map_begin; + const dispatching_map_element_type* end = begin + self->m_dispatching_map_size; + const dispatching_map_element_type* it = std::lower_bound + ( + begin, + end, + dispatching_map_element_type(wrapper, (void*)0), + dispatching_map_order() + ); + + if (it != end && it->first == wrapper) + return callback_base(self->m_visitor, it->second); + else + return callback_base(); + } + + // Copying and assignment closed + BOOST_DELETED_FUNCTION(type_sequence_dispatcher_base(type_sequence_dispatcher_base const&)) + BOOST_DELETED_FUNCTION(type_sequence_dispatcher_base& operator= (type_sequence_dispatcher_base const&)) +}; + +//! A dispatcher that supports a sequence of types +template< typename TypeSequenceT > +class type_sequence_dispatcher : + public type_sequence_dispatcher_base +{ +public: + //! Type sequence of the supported types + typedef TypeSequenceT supported_types; + +private: + //! The dispatching map + typedef array< + std::pair< type_info_wrapper, void* >, + mpl::size< supported_types >::value + > dispatching_map; + +public: + /*! + * Constructor. Initializes the dispatcher internals. + */ + template< typename VisitorT > + explicit type_sequence_dispatcher(VisitorT& visitor) : + type_sequence_dispatcher_base(get_dispatching_map< VisitorT >().data(), dispatching_map::static_size, (void*)boost::addressof(visitor)) + { + } + +private: + //! The method returns the dispatching map instance + template< typename VisitorT > + static dispatching_map const& get_dispatching_map() + { + static const dispatching_map* pinstance = NULL; + + BOOST_LOG_ONCE_BLOCK() + { + static dispatching_map instance; + typename dispatching_map::value_type* p = &*instance.begin(); + + typedef typename mpl::begin< supported_types >::type begin_iterator_type; + typedef typename mpl::end< supported_types >::type end_iterator_type; + typedef dispatching_map_initializer< VisitorT > initializer; + initializer::init(static_cast< begin_iterator_type* >(0), static_cast< end_iterator_type* >(0), p); + + std::sort(instance.begin(), instance.end(), dispatching_map_order()); + + pinstance = &instance; + } + + return *pinstance; + } + + // Copying and assignment closed + BOOST_DELETED_FUNCTION(type_sequence_dispatcher(type_sequence_dispatcher const&)) + BOOST_DELETED_FUNCTION(type_sequence_dispatcher& operator= (type_sequence_dispatcher const&)) +}; + +//! A base class for a single-type dispatcher +class single_type_dispatcher_base : + public type_dispatcher +{ +private: + //! The type to match against + std::type_info const& m_type; + //! A callback for the supported type + callback_base m_callback; + +protected: + //! Initializing constructor + single_type_dispatcher_base(std::type_info const& type, callback_base const& callback) BOOST_NOEXCEPT : + type_dispatcher(&single_type_dispatcher_base::get_callback), + m_type(type), + m_callback(callback) + { + } + +private: + //! The get_callback method implementation + static callback_base get_callback(type_dispatcher* p, std::type_info const& type) + { + single_type_dispatcher_base* const self = static_cast< single_type_dispatcher_base* >(p); + if (type == self->m_type) + return self->m_callback; + else + return callback_base(); + } + + // Copying and assignment closed + BOOST_DELETED_FUNCTION(single_type_dispatcher_base(single_type_dispatcher_base const&)) + BOOST_DELETED_FUNCTION(single_type_dispatcher_base& operator= (single_type_dispatcher_base const&)) +}; + +//! A simple dispatcher that only supports one type +template< typename T > +class single_type_dispatcher : + public single_type_dispatcher_base +{ +public: + //! Constructor + template< typename VisitorT > + explicit single_type_dispatcher(VisitorT& visitor) BOOST_NOEXCEPT : + single_type_dispatcher_base(typeid(visible_type< T >), callback_base((void*)boost::addressof(visitor), &callback_base::trampoline< VisitorT, T >)) + { + } + + // Copying and assignment closed + BOOST_DELETED_FUNCTION(single_type_dispatcher(single_type_dispatcher const&)) + BOOST_DELETED_FUNCTION(single_type_dispatcher& operator= (single_type_dispatcher const&)) +}; + +} // namespace aux + +/*! + * \brief A static type dispatcher class + * + * The type dispatcher can be used to pass objects of arbitrary types from one + * component to another. With regard to the library, the type dispatcher + * can be used to extract attribute values. + * + * Static type dispatchers allow to specify one or several supported types at compile + * time. + */ +template< typename T > +class static_type_dispatcher +#ifndef BOOST_LOG_DOXYGEN_PASS + : + public mpl::if_< + mpl::is_sequence< T >, + boost::log::aux::type_sequence_dispatcher< T >, + boost::log::aux::single_type_dispatcher< T > + >::type +#endif +{ +private: + //! Base type + typedef typename mpl::if_< + mpl::is_sequence< T >, + boost::log::aux::type_sequence_dispatcher< T >, + boost::log::aux::single_type_dispatcher< T > + >::type base_type; + +public: + /*! + * Constructor. Initializes the dispatcher internals. + * + * The \a receiver object is not copied inside the dispatcher, but references to + * it may be kept by the dispatcher after construction. The receiver object must remain + * valid until the dispatcher is destroyed. + * + * \param receiver Unary function object that will be called on a dispatched value. The receiver + * must be callable with an argument of any of the supported types of the dispatcher. + */ + template< typename ReceiverT > + explicit static_type_dispatcher(ReceiverT& receiver) : + base_type(receiver) + { + } + + // Copying and assignment prohibited + BOOST_DELETED_FUNCTION(static_type_dispatcher(static_type_dispatcher const&)) + BOOST_DELETED_FUNCTION(static_type_dispatcher& operator= (static_type_dispatcher const&)) +}; + +BOOST_LOG_CLOSE_NAMESPACE // namespace log + +} // namespace boost + +#include <boost/log/detail/footer.hpp> + +#endif // BOOST_LOG_STATIC_TYPE_DISPATCHER_HPP_INCLUDED_ |