FM / variant

/usr/include/boost/variant

Name	Size	Mode	Actions
detail/	-	0755	rm
apply_visitor.hpp	782	0644	edit dl rm
bad_visit.hpp	1193	0644	edit dl rm
get.hpp	11404	0644	edit dl rm
multivisitors.hpp	1048	0644	edit dl rm
polymorphic_get.hpp	11189	0644	edit dl rm
recursive_variant.hpp	6011	0644	edit dl rm
recursive_wrapper.hpp	3499	0644	edit dl rm
recursive_wrapper_fwd.hpp	5177	0644	edit dl rm
static_visitor.hpp	2605	0644	edit dl rm
variant.hpp	71048	0644	edit dl rm
variant_fwd.hpp	11825	0644	edit dl rm
visitor_ptr.hpp	2210	0644	edit dl rm

Edit: /usr/include/boost/variant/visitor_ptr.hpp (2210B)

#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/throw_exception.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) BOOST_NOEXCEPT
      : visitor_(visitor)
    {
    }

public: // static visitor interfaces

template <typename U>
    result_type operator()(const U&) const
    {
        boost::throw_exception(bad_visit());
    }

public: // static visitor interfaces, cont.

result_type operator()(argument_fwd_type operand) const
    {
        return visitor_(operand);
    }

};

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

//----------------------------------------------------------------------------- // 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 #include #include #include #include #include #include #include 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 class visitor_ptr_t : public static_visitor { 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 , mpl::identity , add_reference >::type argument_fwd_type; public: // structors explicit visitor_ptr_t(visitor_t visitor) BOOST_NOEXCEPT : visitor_(visitor) { } public: // static visitor interfaces template result_type operator()(const U&) const { boost::throw_exception(bad_visit()); } public: // static visitor interfaces, cont. result_type operator()(argument_fwd_type operand) const { return visitor_(operand); } }; template inline visitor_ptr_t visitor_ptr(R (*visitor)(T)) { return visitor_ptr_t(visitor); } } // namespace boost #endif// BOOST_VISITOR_VISITOR_PTR_HPP