boolean_function.h

#pragma once

namespace boloq {

template<class T>
class basic_boolean_function {
private:
    using table_type = T;
    using self_type = basic_boolean_function<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;

    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_boolean_function() : _root(nullptr) {}

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

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

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

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

    self_type ite(const self_type& then_node, const self_type& else_node) const {
        return self_type(table().ite(_root, then_node._root, else_node._root));
    }

    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 {
        return self_type(table().apply_not(_root));
    }

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

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

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

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


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

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

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

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

    bool is_wire() const {
        return visit_result<is_wire_visitor<self_type>, bool>();
    }

    bool is_negation() const {
        return visit_result<is_negation_visitor<self_type>, bool>();
    }

    bool is_conjunction() const {
        return visit_result<is_conjunction_visitor<self_type>, bool>();
    }

    bool is_disjunction() const {
        return visit_result<is_disjunction_visitor<self_type>, bool>();
    }

    bool is_exclusive_disjunction() const {
        return visit_result<is_exclusive_disjunction_visitor<self_type>, bool>();
    }

};

using boolean_function = basic_boolean_function<boolean_function_cache>;

}

namespace std {

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

}