/*
I'm playing around with Boost Variant in order to create a tree made out of nodes
that can either be a value (leaf), or a set of one or two children
The problem is that nesting doesn't work for a single child case - I have wrong depth here
*/
#define BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
#include <boost/variant.hpp>
#include <iostream>
#include <typeinfo>
typedef boost::make_recursive_variant<
// can be one of
int,
bool,
boost::recursive_variant_, // single child
std::pair<boost::recursive_variant_, boost::recursive_variant_> // two children
>::type Node;
struct TreePrint : public boost::static_visitor<void> {
mutable int depth;
template <typename T>
void operator()(const T& value) const {
depth++;
std::cout << "[depth " << depth << "]: " << value << std::endl;
depth--;
}
void operator()(const Node& value) const {
depth++;
boost::apply_visitor(*this, value);
depth--;
}
void operator()(const std::pair<Node, Node>& value) const {
depth++;
boost::apply_visitor(*this, value.first);
boost::apply_visitor(*this, value.second);
depth--;
}
};
int main() {
/*
root
/ \
i1 i2
/ \ \
t1 5 t1
/ \ \
1 true 10
*/
Node root(
std::pair<Node, Node>(
std::pair<Node, Node>( // i1
std::pair<Node, Node>( // t1
1,
true
),
5
),
Node( // i2
Node( // t1
Node(10) // ERROR - should have depth 4
)
)
)
);
boost::apply_visitor(TreePrint(), root );
}
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