combination.h

#pragma once

namespace boloq {

template<class T>
class basic_combination {
private:
    using table_type = T;
    using self_type = basic_combination<table_type>;
    friend std::hash<self_type>;

public:
    using node_ptr = typename table_type::node_ptr;

    using label_type = typename table_type::node_type::label_type;

private:
    node_ptr _root;

    explicit basic_combination(const node_ptr& r) :
            _root(r)
    {}

    static table_type& table() {
        static table_type instance;
        return instance;
    }

    template<class V, typename R, typename ...Args>
    R visit_result(const Args& ...args) const {
        V v(args...);
        this->accept(v);
        return v.result();
    }

public:

    basic_combination() : _root(nullptr) {}

    explicit basic_combination(const label_type& _label) :
            _root(table().new_var(_label))
    {}

    static const self_type one() {
        return self_type(table().one());
    }

    static const self_type zero() {
        return self_type(table().zero());
    }

    self_type& change(const label_type& v) {
        _root = table().apply_change(_root, v);
        return *this;
    }

    self_type changed(const label_type& v) {
        return self_type(table().apply_change(_root, v));
    }

    bool operator==(const self_type& o) const {
        return _root->index() == o._root->index();
    }

    bool operator!=(const self_type& o) const {
        return _root->index() != o._root->index();
    }

    self_type operator+(const self_type& o) const {
        return self_type(table().apply_union(_root, o._root));
    }

    self_type& operator+=(const self_type& o) {
        _root = table().apply_union(_root, o.root);
        return *this;
    }

    self_type operator-(const self_type& o) const {
        return self_type(table().apply_subtract(_root, o._root));
    }

    self_type& operator-=(const self_type& o) {
        _root = table().apply_subtract(_root, o.root);
        return *this;
    }

    self_type operator&(const self_type& o) const {
        return self_type(table().apply_intersection(_root, o._root));
    }

    self_type& operator&=(const self_type& o) {
        _root = table().apply_intersection(_root, o._root);
        return *this;
    }

    template<class V>
    void accept(V& visitor) const {
        _root->accept(visitor);
    }

    template<class AssignT>
    bool contain(const AssignT& assign) const {
        return visit_result<contain_visitor<self_type, AssignT>, bool>(assign);
    }

};

using combination = basic_combination<combination_cache>;

}

namespace std {

template<class T>
struct hash<boloq::basic_combination<T>> {
    std::hash<typename boloq::basic_combination<T>::node_ptr> hash_fn;
    size_t operator()(const boloq::basic_combination<T>& bf) const {
        return hash_fn(bf._root);
    }
};

}