block.hpp

Go to the documentation of this file.

/*
 * Copyright 2023 Blue Brain Project, EPFL.
 * See the top-level LICENSE file for details.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
///
/// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
///
 
#pragma once
 
/**
 * \dir
 * \brief Auto generated AST Implementations
 *
 * \file
 * \brief Auto generated AST classes declaration
 */
 
#include "ast/ast_decl.hpp"
#include "ast/expression.hpp"
 
namespace nmodl::ast {
 
/**
 * \addtogroup ast_class
 * \ingroup ast
 * \{
 */
 
/**
 * \brief Base class for all block scoped nodes
 *
 * NMODL has different local and globals block scoped nodes like
  * ast::NeuronBlock, ast::ParamBlock, ast::IfStatement etc. Ast::Block
  * is base class and defines common interface for these nodes.
  * 
*/
class Block : public Expression {
 
  public:
  /// \name Ctor & dtor
  /// \{
    virtual ~Block() = default;
  /// \}
  /// \name Not implemented
  /// \{
    virtual const ArgumentVector& get_parameters() const {
      throw std::runtime_error("get_parameters not implemented");
    }
  /// \}
  /**
   * \brief Check if the ast node is an instance of ast::Block
   * \return true as object is of type ast::Block
   */
  bool is_block () const noexcept override {
    return true;
  }
 
  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * \return pointer to the clone/copy of the current node
   */
  // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks)
   virtual  Block* clone() const override {
    return new Block(*this);
  }
  // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 
  /// \name Getters
  /// \{
 
  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BLOCK;
  }
 
  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Block"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Block";
  }
 
 
  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Block>(shared_from_this());
  }
 
  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Block>(shared_from_this());
  }
 
  /// \}
 
 
 
  /// \name Visitor
  /// \{
  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;
 
  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;
 
  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;
 
  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;
  /// \}
 
};
 
/** \} */  // end of ast_class
 
 
}  // namespace nmodl::ast