Class NaryNode

src/backend/common/jit/NaryNode.hpp:27–101

namespace common {

class NaryNode : public Node {
   private:
    int m_num_children;
    const char *m_op_str;

   protected:
    af_op_t m_op;

   public:
    NaryNode(const af::dtype type, const char *op_str, const int num_children,
             const std::array<common::Node_ptr, Node::kMaxChildren> &&children,
             const af_op_t op, const int height)
        : common::Node(
              type, height,
              std::forward<
                  const std::array<common::Node_ptr, Node::kMaxChildren>>(
                  children),
              kNodeType::Nary)
        , m_num_children(num_children)
        , m_op_str(op_str)
        , m_op(op) {
        static_assert(std::is_nothrow_move_assignable<NaryNode>::value,
                      "NaryNode is not move assignable");
        static_assert(std::is_nothrow_move_constructible<NaryNode>::value,
                      "NaryNode is not move constructible");
    }

    NaryNode(NaryNode &&other) noexcept = default;

    NaryNode(const NaryNode &other) = default;

    /// Default copy assignment operator
    NaryNode &operator=(const NaryNode &node) = default;

    /// Default move assignment operator
    NaryNode &operator=(NaryNode &&node) noexcept = default;

    void swap(NaryNode &other) noexcept {
        using std::swap;
        Node::swap(other);
        swap(m_num_children, other.m_num_children);
        swap(m_op_str, other.m_op_str);
        swap(m_op, other.m_op);
    }

    af_op_t getOp() const noexcept final { return m_op; }

    virtual std::unique_ptr<Node> clone() override {
        return std::make_unique<NaryNode>(*this);
    }

    void genKerName(std::string &kerString,
                    const common::Node_ids &ids) const final {
        // Make the dec representation of enum part of the Kernel name
        kerString += '_';
        kerString += std::to_string(m_op);
        kerString += ',';
        for (int i = 0; i < m_num_children; i++) {