internal_node.h

Go to the documentation of this file.

#ifndef META_PARSE_INTERNAL_NODE_H_
#define META_PARSE_INTERNAL_NODE_H_

#include <memory>
#include <vector>
#include "parser/trees/node.h"
#include "util/clonable.h"

namespace meta
{
namespace parser
{

class leaf_node;

class internal_node : public util::clonable<node, internal_node>
{
  public:
    using base = util::clonable<node, internal_node>;

    using base::base;

    template <class FwdIt>
    internal_node(class_label cat, FwdIt begin, FwdIt end)
        : base{std::move(cat)}
    {
        auto dist = std::distance(begin, end);
        children_.reserve(dist);
        for (; begin != end; ++begin)
            children_.emplace_back(std::move(*begin));
    }

    internal_node(class_label cat,
                  std::vector<std::unique_ptr<node>>&& children);

    internal_node(const internal_node&);

    void add_child(std::unique_ptr<node> child);

    uint64_t num_children() const;

    const node* child(uint64_t idx) const;

    bool is_leaf() const override;

    bool equal(const node& other) const override;

    const leaf_node* head_lexicon() const;

    void head_lexicon(const leaf_node* l);

    const node* head_constituent() const;

    void head_constituent(const node* n);

    void head(const node* n);

    template <class Fun>
    void each_child(Fun&& fn) const
    {
        for (const auto& child : children_)
            fn(child.get());
    }

    template <class Fun>
    void each_child(Fun&& fn)
    {
        for (auto& child : children_)
            fn(child.get());
    }

  private:
    std::vector<std::unique_ptr<node>> children_;

    const leaf_node* head_lexicon_ = nullptr;

    const node* head_constituent_ = nullptr;
};
}
}

#endif