Forward boost::variant from a visitor to another - c++

Question

I want to call a visitor on a boost variant from inside another visitor. Consider the following code:
struct visitor1 : boost::static_visitor<>
{
void operator()(const int& i) const { std::cout << "visitor1:" << i; }
void operator()(const std::string & str) const { std::cout << "visitor1, string: " << str}
};
struct visitor2 : boost::static_visitor<>
{
void operator()(const int& i) const
{
// apply visitor1 here
boost::apply_visitor(visitor1(), /* is there a context reference to the variant here? */)
std::cout << "visitor 2 applied visitor 1";
}
void operator()(const std::string & str) const { //... }
};
int main()
{
boost::variant< int, std::string> v = 5;
boost::apply_visitor(visitor2 (), v );
}
Should output:
visitor1: 5
Visitor 2 applied visitor 1

Answer 1

If you want to take the variant, just call it directly (witout apply_visitor).
If you want to take it in addition just use bind or similar:
Live On Coliru
#include <boost/variant.hpp>
#include <boost/bind.hpp>
#include <iostream>
struct visitor1 : boost::static_visitor<>
{
void operator()(const int& i) const { std::cout << "visitor1:" << i << "\n"; }
void operator()(const std::string & str) const { std::cout << "visitor1, string: " << str << "\n"; }
};
struct visitor2 : boost::static_visitor<>
{
template <typename Variant>
void operator()(const int& i, Variant const& v) const
{
boost::apply_visitor(visitor1(), v);
std::cout << "visitor 2 applied visitor 1" << " (int " << i << ")\n";
}
template <typename Variant>
void operator()(const std::string & str, Variant const& v) const {
boost::apply_visitor(visitor1(), v);
std::cout << "visitor 2 applied visitor 1" << " (string " << str << ")\n";
}
};
int main()
{
using V = boost::variant< int, std::string>;
for (V v : { V{5}, V{"something"} })
boost::apply_visitor(boost::bind(visitor2(), _1, boost::ref(v)), v);
}
Prints
visitor1:5
visitor 2 applied visitor 1 (int 5)
visitor1, string: something
visitor 2 applied visitor 1 (string something)
Alternative Without Bind
If you prefer DIY you can emulate the "bind" easily:
Live On Coliru
template <typename V>
struct visitor2 {
typedef void result_type;
V const* _ref;
void operator()(const int& i) const {
boost::apply_visitor(visitor1(), *_ref);
std::cout << "visitor 2 applied visitor 1" << " (int " << i << ")\n";
}
void operator()(const std::string & str) const {
boost::apply_visitor(visitor1(), *_ref);
std::cout << "visitor 2 applied visitor 1" << " (string " << str << ")\n";
}
};
int main()
{
using V = boost::variant< int, std::string>;
for (V v : { V{5}, V{"something"} })
boost::apply_visitor(visitor2<V>{&v}, v);
}
Printing
visitor1:5
visitor 2 applied visitor 1 (int 5)
visitor1, string: something
visitor 2 applied visitor 1 (string something)
A Stylistic Note:
I like to make the function object Variant-aware, and then you can hide the "double bind":
Live On Coliru
struct visitor2 {
typedef void result_type;
template <typename... Ts>
void operator()(boost::variant<Ts...> const& v) const {
return boost::apply_visitor(boost::bind(*this, _1, boost::cref(v)), v);
}
template <typename Variant>
void operator()(const int& i, Variant const& v) const {
boost::apply_visitor(visitor1(), v);
std::cout << "visitor 2 applied visitor 1" << " (int " << i << ")\n";
}
template <typename Variant>
void operator()(const std::string & str, Variant const& v) const {
boost::apply_visitor(visitor1(), v);
std::cout << "visitor 2 applied visitor 1" << " (string " << str << ")\n";
}
};
int main()
{
using V = boost::variant< int, std::string>;
for (V v : { V{5}, V{"something"} })
visitor2{}(v);
}
Prints
visitor1:5
visitor 2 applied visitor 1 (int 5)
visitor1, string: something
visitor 2 applied visitor 1 (string something)