node.h

#pragma once

namespace boloq {

template<class LT, class IT>
class basic_node : public std::enable_shared_from_this<const basic_node<LT, IT>> {
private:
    using self_type = basic_node<LT, IT>;

public:
    using index_type = IT;
    using label_type = LT;
    using node_ptr = std::shared_ptr<const self_type>;

private:
    const index_type _index;
    const label_type _label;

    const node_ptr _then_node;
    const node_ptr _else_node;

    const node_ptr self() const {
        return this->shared_from_this();
    }

public:

    explicit constexpr basic_node(const index_type& i) :
            _index(i), _label(std::numeric_limits<label_type>::max()),
            _then_node(nullptr), _else_node(nullptr)
    {}

    constexpr basic_node(const index_type& i, const label_type& l, const node_ptr& _then, const node_ptr& _else) :
        _index(i), _label(l), _then_node(_then), _else_node(_else)
    {}

    constexpr const index_type& index() const {return _index;}

    constexpr const label_type& label() const {return _label;}

    constexpr bool is_terminal() const {return index() < 2;};

    const node_ptr then_node() const {
        if (is_terminal()) return self();
        return _then_node;
    }
    const node_ptr else_node() const {
        if (is_terminal()) return self();
        return _else_node;
    }

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

using node = basic_node<size_t, size_t>;

struct null_deleter {
    void operator()(void const *) const {}
};

}