CODEWITHSUNDEEP
c++boost
Michael EstrinOne
Michael EstrinOne

Reputation: 465

boost::variant comparison with contained value

I am trying to find a way to compare boost::variant with underlying value without constructing variant from this underlying value. The question is defined in the comment in "main()" function And auxiliary question is about the comparison operators defined in the code. How to decrease the # of comparison operators? If boost::variant contains, say, 6 different types, do I have to define 6! operators to be able to compare two variants?

Thanks!

#include <boost/variant.hpp>
namespace test {

    namespace Tag {
        struct Level1{ int t{ 1 }; };
        struct Level2{ int t{ 2 }; };
    }

    template <typename Kind> struct Node;

    using LevelOne = Node<Tag::Level1>;
    using LevelTwo = Node<Tag::Level2>;

    using VariantNode = boost::variant
    <
        boost::recursive_wrapper<LevelOne>,
        boost::recursive_wrapper<LevelTwo>
    >;

    typedef VariantNode* pTree;
    typedef std::vector<pTree> lstTree;

    template <typename Kind> struct Node
    {
        Node(pTree p, std::string n) : parent(p), name(n) {}
        Node(const Node& another) : name(another.name), parent(another.parent) {}
        virtual ~Node() {}
        std::string name;
        pTree parent;
    };

    bool operator == (const LevelOne& one, const LevelTwo& two) {
        return false;
    }
    bool operator == (const LevelTwo& two, const LevelOne& one) {
        return false;
    }
    bool operator == (const LevelOne& one, const LevelOne& two) {
        return true;
    }
    bool operator == (const LevelTwo& one, const LevelTwo& two) {
        return true;
    }
}

int main(int argc, char *argv[])
{
    using namespace test;
    LevelOne l1(nullptr, "level one");
    VariantNode tl2 = VariantNode(LevelTwo(nullptr, "level two"));
    VariantNode tl1 = VariantNode(LevelOne(nullptr, "level one"));
    bool rv = (tl1 == tl2); // this line compiles OK (comparing two variants)
    // comparison below does not compile, because "l1" is not a variant. 
    // Question: How can I compare "variant" value "tl1" 
    // with one of the possible content values "l1"
    bool rv1 = (tl1 == l1); 
    return 1;
}

Upvotes: 0

Views: 905

Answers (1)

ildjarn
ildjarn

Reputation: 62985

The following will work with any number of types in the variant:

template<typename T>
struct equality_visitor : boost::static_visitor<bool> {
    explicit constexpr equality_visitor(T const& t) noexcept : t_{ &t } { }

    template<typename U, std::enable_if_t<std::is_same<T, U>::value>* = nullptr>
    constexpr bool operator ()(U const& u) const {
        return *t_ == u;
    }

    template<typename U, std::enable_if_t<!std::is_same<T, U>::value>* = nullptr>
    constexpr bool operator ()(U const&) const {
        return false;
    }

private:
    T const* t_;
};

template<
    typename T,
    typename... Ts,
    typename = std::enable_if_t<
        boost::mpl::contains<typename boost::variant<Ts...>::types, T>::value
    >
>
bool operator ==(T const& t, boost::variant<Ts...> const& v) {
    equality_visitor<T> ev{ t };
    return v.apply_visitor(ev);
}

template<
    typename T,
    typename... Ts,
    typename = std::enable_if_t<
        boost::mpl::contains<typename boost::variant<Ts...>::types, T>::value
    >
>
bool operator !=(T const& t, boost::variant<Ts...> const& v) {
    return !(t == v);
}

The catch is that comparisons must always be of the form value == variant or value != variant rather than variant == value or variant != value. This is because boost::variant<> itself defines these operators to always static_assert, and there is no way for us to make a global operator more specialized than variant<>'s built-in ones.

Online Demo

Upvotes: 3

Related Questions