//-----------------------------------------------------------------------------

 // boost variant/visitor_ptr.hpp header file

 // See http://www.boost.org for updates, documentation, and revision history.

 //-----------------------------------------------------------------------------

 //

 // Copyright (c) 2002-2003

 // Eric Friedman

 //

 // 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_VARIANT_VISITOR_PTR_HPP

 #define BOOST_VARIANT_VISITOR_PTR_HPP

 #include "boost/variant/bad_visit.hpp"

 #include "boost/variant/static_visitor.hpp"

 #include "boost/mpl/eval_if.hpp"

 #include "boost/mpl/identity.hpp"

 #include "boost/type_traits/add_reference.hpp"

 #include "boost/type_traits/is_reference.hpp"

 #include "boost/type_traits/is_void.hpp"

 namespace boost {

 //////////////////////////////////////////////////////////////////////////

 // function template visitor_ptr

 //

 // Adapts a function pointer for use as visitor capable of handling

 // values of a single type. Throws bad_visit if inappropriately applied.

 //

 template <typename T, typename R>

 class visitor_ptr_t

     : public static_visitor<R>

 {

 private: // representation

     typedef R (*visitor_t)(T);

     visitor_t visitor_;

 public: // typedefs

     typedef R result_type;

 private: // private typedefs

     typedef typename mpl::eval_if<

           is_reference<T>

         , mpl::identity<T>

         , add_reference<const T>

         >::type argument_fwd_type;

 public: // structors

     explicit visitor_ptr_t(visitor_t visitor)

       : visitor_(visitor)

     {

     }

 public: // static visitor interfaces

     template <typename U>

     result_type operator()(const U&) const

     {

         throw bad_visit();

     }

 #if !defined(BOOST_NO_VOID_RETURNS)

 public: // static visitor interfaces, cont.

     result_type operator()(argument_fwd_type operand) const

     {

         return visitor_(operand);

     }

 #else // defined(BOOST_NO_VOID_RETURNS)

 private: // helpers, for static visitor interfaces (below)

     result_type execute_impl(argument_fwd_type operand, mpl::false_) const

     {

         return visitor_(operand);

     }

         BOOST_VARIANT_AUX_RETURN_VOID_TYPE

     execute_impl(argument_fwd_type operand, mpl::true_) const

     {

         visitor_(operand);

         BOOST_VARIANT_AUX_RETURN_VOID;

     }

 public: // static visitor interfaces, cont.

         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)

     operator()(argument_fwd_type operand) const

     {

         typedef typename is_void<result_type>::type has_void_result;

         return execute_impl(operand, has_void_result());

     }

 #endif // BOOST_NO_VOID_RETURNS workaround

 };

 template <typename R, typename T>

 inline visitor_ptr_t<T,R> visitor_ptr(R (*visitor)(T))

 {

     return visitor_ptr_t<T,R>(visitor);

 }

 } // namespace boost

 #endif// BOOST_VISITOR_VISITOR_PTR_HPP