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

 // boost-libs variant/libs/test/jobs.h header file

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

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

 //

 // Copyright (c) 2003

 // Eric Friedman, Itay Maman

 //

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

 #define _JOBSH_INC_

 #include <algorithm>

 #include <iostream>

 #include <sstream>

 #include <string>

 #include <typeinfo>

 #include <vector>

 #include "boost/variant/variant_fwd.hpp"

 #include "boost/variant/get.hpp"

 #include "boost/variant/apply_visitor.hpp"

 #include "boost/variant/static_visitor.hpp"

 #include "boost/detail/workaround.hpp"

 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))

 #    pragma warn -lvc

 #endif

 struct to_text : boost::static_visitor<std::string>

 {

 private: // NO_FUNCTION_TEMPLATE_ORDERING workaround

     template < BOOST_VARIANT_ENUM_PARAMS(typename U) >

     std::string to_text_impl(

           const boost::variant< BOOST_VARIANT_ENUM_PARAMS(U) >& operand, long

         ) const

     {

         std::ostringstream ost;

         ost << "[V] " << boost::apply_visitor(to_text(), operand);

         return ost.str();

     }

     template <typename Value>

     std::string to_text_impl(const Value& operand, int) const

     {

         std::ostringstream ost;

         ost << "[V] " << operand;

         return ost.str();

     }

 public:

     template <typename T>

     std::string operator()(const T& operand) const

     {

         return to_text_impl(operand, 1L);

     }

 };

 struct total_sizeof : boost::static_visitor<int>

 {

    total_sizeof() : total_(0) { }

    template<class Value>

    int operator()(const Value&) const

    {

       total_ += sizeof(Value);

       return total_;

    }

    int result() const

    {

       return total_;

    }

    mutable int total_;

 }; // total_sizeof

 //Function object: sum_int

 //Description: Compute total sum of a series of numbers, (when called successively)

 //Use sizeof(T) if applied with a non-integral type

 struct sum_int : boost::static_visitor<int>

 {

    sum_int() : total_(0) { }

    template<int n>

    struct int_to_type

    {

       BOOST_STATIC_CONSTANT(int, value = n);

    }; 

    //Integral type - add numerical value

    template<typename T>

    void add(T t, int_to_type<true> ) const

    {

       total_ += t;

    }

    //Other types - add sizeof<T>

    template<typename T>

    void add(T& , int_to_type<false> ) const

    {

       total_ += sizeof(T);

    }

    template<typename T>

    int operator()(const T& t) const

    {

       //Int_to_type is used to select the correct add() overload

       add(t, int_to_type<boost::is_integral<T>::value>());

       return total_;

    }

    int result() const

    {

       return total_;

    }

 private:

    mutable int total_;

 }; //sum_int

 //Function object: sum_double

 //Description: Compute total sum of a series of numbers, (when called successively)

 //Accpetable input types: float, double (Other types are silently ignored)

 struct sum_double : boost::static_visitor<double>

 {

    sum_double() : total_(0) { }

    void operator()(float value) const

    {

       total_ += value;

    }

    void operator()(double value) const

    {

       total_ += value;

    }

    template<typename T>

    void operator()(const T&) const

    {

       //Do nothing

    }

    double result() const

    {

       return total_;

    }

 private:

    mutable double total_;

 }; //sum_double

 struct int_printer : boost::static_visitor<std::string>

 {

    int_printer(std::string prefix_s = "") : prefix_s_(prefix_s) { }

    int_printer(const int_printer& other) : prefix_s_(other.prefix_s_)

    {

       ost_ << other.str();

    }

    std::string operator()(int x) const

    {

       ost_ << prefix_s_ << x;

       return str();

    }

    std::string operator()(const std::vector<int>& x) const

    {

       ost_ << prefix_s_;

       //Use another Int_printer object for printing a list of all integers

       int_printer job(",");

       ost_ << std::for_each(x.begin(), x.end(), job).str();

       return str();

    }

    std::string str() const

    {

       return ost_.str();

    }

 private:

    std::string prefix_s_;

    mutable std::ostringstream ost_;

 };  //int_printer

 struct int_adder : boost::static_visitor<>

 {

    int_adder(int rhs) : rhs_(rhs) { }

    result_type operator()(int& lhs) const

    {

       lhs += rhs_;

    }

    template<typename T>

    result_type operator()(const T& ) const

    {

       //Do nothing

    }

    int rhs_;

 }; //int_adder

 struct held_type_name : boost::static_visitor<std::string>

 {

    template<typename T>

    std::string operator()(const T& ) const

    {

       ost_ << '[' << typeid(T).name() << ']';

       return result();

    }

    std::string result() const

    {

       return ost_.str();

    }

    mutable std::ostringstream ost_;

 }; //held_type_name

 template<typename T>

 struct spec 

 {

    typedef T result;

 };

 template<typename VariantType, typename S>

 inline void verify(VariantType& var, spec<S>, std::string str = "")

 {

    const VariantType& cvar = var;

    BOOST_CHECK(boost::apply_visitor(total_sizeof(), cvar) == sizeof(S));

    BOOST_CHECK(cvar.type() == typeid(S));

    //

    // Check get<>()

    //

    BOOST_CHECK(boost::get<S>(&var));

    BOOST_CHECK(boost::get<S>(&cvar));

    const S* ptr1 = 0;

    const S* ptr2 = 0;

    try

    {

       S& r = boost::get<S>(var);

       ptr1 = &r;

    }

    catch(boost::bad_get& )

    {

       BOOST_ERROR( "get<S> failed unexpectedly" );

    }

    try

    {

       const S& cr = boost::get<S>(cvar);

       ptr2 = &cr;

    }

    catch(boost::bad_get& )

    {

       BOOST_ERROR( "get<S> const failed unexpectedly" );

    }

    BOOST_CHECK(ptr1 != 0 && ptr2 == ptr1);

    //

    // Check string content

    //

    if(str.length() > 0)

    {

       std::string temp = boost::apply_visitor(to_text(), cvar);

       std::cout << "temp = " << temp << ", str = " << str << std::endl;

       BOOST_CHECK(temp == str);         

    }

 }

 template<typename VariantType, typename S>

 inline void verify_not(VariantType& var, spec<S>)

 {

    const VariantType& cvar = var;

    BOOST_CHECK(cvar.type() != typeid(S));

    //

    // Check get<>()

    //

    BOOST_CHECK(!boost::get<S>(&var));

    BOOST_CHECK(!boost::get<S>(&cvar));

    const S* ptr1 = 0;

    const S* ptr2 = 0;

    try

    {

       S& r = boost::get<S>(var); // should throw

       BOOST_ERROR( "get<S> passed unexpectedly" );

       ptr1 = &r;

    }

    catch(boost::bad_get& )

    {

       // do nothing except pass-through

    }

    try

    {

       const S& cr = boost::get<S>(var); // should throw

       BOOST_ERROR( "get<S> const passed unexpectedly" );

       ptr2 = &cr;

    }

    catch(boost::bad_get& )

    {

       // do nothing except pass-through

    }

    BOOST_CHECK(ptr1 == 0 && ptr2 == 0);   

 }

 #endif //_JOBSH_INC_