ast.cpp

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.
///
 
#include "ast/all.hpp"
#include "symtab/symbol_table.hpp"
 
/**
 * \file
 * \brief Auto generated AST classes implementations
 */
 
namespace nmodl::ast {
 
///
///  Ast member function definition
///
 
Ast *Ast::clone() const { throw std::logic_error("clone not implemented"); }
 
std::string Ast::get_node_name() const {
  throw std::logic_error("get_node_name() not implemented");
}
 
std::shared_ptr<StatementBlock> Ast::get_statement_block() const {
  throw std::runtime_error("get_statement_block not implemented");
}
 
const ModToken *Ast::get_token() const { return nullptr; }
 
symtab::SymbolTable *Ast::get_symbol_table() const {
  throw std::runtime_error("get_symbol_table not implemented");
}
 
void Ast::set_symbol_table(symtab::SymbolTable * /*symtab*/) {
  throw std::runtime_error("set_symbol_table not implemented");
}
 
void Ast::set_name(const std::string & /*name*/) {
  throw std::runtime_error("set_name not implemented");
}
 
void Ast::negate() { throw std::runtime_error("negate not implemented"); }
 
std::shared_ptr<Ast> Ast::get_shared_ptr() {
  return std::static_pointer_cast<Ast>(shared_from_this());
}
 
std::shared_ptr<const Ast> Ast::get_shared_ptr() const {
  return std::static_pointer_cast<const Ast>(shared_from_this());
}
 
bool Ast::is_ast() const noexcept { return true; }
 
bool Ast::is_node () const noexcept { return false; }
 
bool Ast::is_statement () const noexcept { return false; }
 
bool Ast::is_expression () const noexcept { return false; }
 
bool Ast::is_block () const noexcept { return false; }
 
bool Ast::is_identifier () const noexcept { return false; }
 
bool Ast::is_number () const noexcept { return false; }
 
bool Ast::is_string () const noexcept { return false; }
 
bool Ast::is_integer () const noexcept { return false; }
 
bool Ast::is_float () const noexcept { return false; }
 
bool Ast::is_double () const noexcept { return false; }
 
bool Ast::is_boolean () const noexcept { return false; }
 
bool Ast::is_name () const noexcept { return false; }
 
bool Ast::is_prime_name () const noexcept { return false; }
 
bool Ast::is_indexed_name () const noexcept { return false; }
 
bool Ast::is_var_name () const noexcept { return false; }
 
bool Ast::is_argument () const noexcept { return false; }
 
bool Ast::is_react_var_name () const noexcept { return false; }
 
bool Ast::is_read_ion_var () const noexcept { return false; }
 
bool Ast::is_write_ion_var () const noexcept { return false; }
 
bool Ast::is_nonspecific_cur_var () const noexcept { return false; }
 
bool Ast::is_electrode_cur_var () const noexcept { return false; }
 
bool Ast::is_range_var () const noexcept { return false; }
 
bool Ast::is_global_var () const noexcept { return false; }
 
bool Ast::is_pointer_var () const noexcept { return false; }
 
bool Ast::is_random_var () const noexcept { return false; }
 
bool Ast::is_bbcore_pointer_var () const noexcept { return false; }
 
bool Ast::is_extern_var () const noexcept { return false; }
 
bool Ast::is_param_block () const noexcept { return false; }
 
bool Ast::is_independent_block () const noexcept { return false; }
 
bool Ast::is_assigned_block () const noexcept { return false; }
 
bool Ast::is_state_block () const noexcept { return false; }
 
bool Ast::is_initial_block () const noexcept { return false; }
 
bool Ast::is_constructor_block () const noexcept { return false; }
 
bool Ast::is_destructor_block () const noexcept { return false; }
 
bool Ast::is_statement_block () const noexcept { return false; }
 
bool Ast::is_derivative_block () const noexcept { return false; }
 
bool Ast::is_linear_block () const noexcept { return false; }
 
bool Ast::is_non_linear_block () const noexcept { return false; }
 
bool Ast::is_discrete_block () const noexcept { return false; }
 
bool Ast::is_function_table_block () const noexcept { return false; }
 
bool Ast::is_function_block () const noexcept { return false; }
 
bool Ast::is_procedure_block () const noexcept { return false; }
 
bool Ast::is_net_receive_block () const noexcept { return false; }
 
bool Ast::is_solve_block () const noexcept { return false; }
 
bool Ast::is_breakpoint_block () const noexcept { return false; }
 
bool Ast::is_before_block () const noexcept { return false; }
 
bool Ast::is_after_block () const noexcept { return false; }
 
bool Ast::is_ba_block () const noexcept { return false; }
 
bool Ast::is_for_netcon () const noexcept { return false; }
 
bool Ast::is_kinetic_block () const noexcept { return false; }
 
bool Ast::is_unit_block () const noexcept { return false; }
 
bool Ast::is_constant_block () const noexcept { return false; }
 
bool Ast::is_neuron_block () const noexcept { return false; }
 
bool Ast::is_unit () const noexcept { return false; }
 
bool Ast::is_double_unit () const noexcept { return false; }
 
bool Ast::is_local_var () const noexcept { return false; }
 
bool Ast::is_limits () const noexcept { return false; }
 
bool Ast::is_number_range () const noexcept { return false; }
 
bool Ast::is_constant_var () const noexcept { return false; }
 
bool Ast::is_binary_operator () const noexcept { return false; }
 
bool Ast::is_unary_operator () const noexcept { return false; }
 
bool Ast::is_reaction_operator () const noexcept { return false; }
 
bool Ast::is_paren_expression () const noexcept { return false; }
 
bool Ast::is_binary_expression () const noexcept { return false; }
 
bool Ast::is_diff_eq_expression () const noexcept { return false; }
 
bool Ast::is_unary_expression () const noexcept { return false; }
 
bool Ast::is_non_lin_equation () const noexcept { return false; }
 
bool Ast::is_lin_equation () const noexcept { return false; }
 
bool Ast::is_function_call () const noexcept { return false; }
 
bool Ast::is_watch () const noexcept { return false; }
 
bool Ast::is_ba_block_type () const noexcept { return false; }
 
bool Ast::is_unit_def () const noexcept { return false; }
 
bool Ast::is_factor_def () const noexcept { return false; }
 
bool Ast::is_valence () const noexcept { return false; }
 
bool Ast::is_unit_state () const noexcept { return false; }
 
bool Ast::is_local_list_statement () const noexcept { return false; }
 
bool Ast::is_model () const noexcept { return false; }
 
bool Ast::is_define () const noexcept { return false; }
 
bool Ast::is_include () const noexcept { return false; }
 
bool Ast::is_param_assign () const noexcept { return false; }
 
bool Ast::is_assigned_definition () const noexcept { return false; }
 
bool Ast::is_conductance_hint () const noexcept { return false; }
 
bool Ast::is_expression_statement () const noexcept { return false; }
 
bool Ast::is_protect_statement () const noexcept { return false; }
 
bool Ast::is_from_statement () const noexcept { return false; }
 
bool Ast::is_while_statement () const noexcept { return false; }
 
bool Ast::is_if_statement () const noexcept { return false; }
 
bool Ast::is_else_if_statement () const noexcept { return false; }
 
bool Ast::is_else_statement () const noexcept { return false; }
 
bool Ast::is_watch_statement () const noexcept { return false; }
 
bool Ast::is_mutex_lock () const noexcept { return false; }
 
bool Ast::is_mutex_unlock () const noexcept { return false; }
 
bool Ast::is_conserve () const noexcept { return false; }
 
bool Ast::is_compartment () const noexcept { return false; }
 
bool Ast::is_lon_diffuse () const noexcept { return false; }
 
bool Ast::is_reaction_statement () const noexcept { return false; }
 
bool Ast::is_lag_statement () const noexcept { return false; }
 
bool Ast::is_constant_statement () const noexcept { return false; }
 
bool Ast::is_table_statement () const noexcept { return false; }
 
bool Ast::is_suffix () const noexcept { return false; }
 
bool Ast::is_useion () const noexcept { return false; }
 
bool Ast::is_nonspecific () const noexcept { return false; }
 
bool Ast::is_electrode_current () const noexcept { return false; }
 
bool Ast::is_range () const noexcept { return false; }
 
bool Ast::is_global () const noexcept { return false; }
 
bool Ast::is_random_var_list () const noexcept { return false; }
 
bool Ast::is_pointer () const noexcept { return false; }
 
bool Ast::is_bbcore_pointer () const noexcept { return false; }
 
bool Ast::is_external () const noexcept { return false; }
 
bool Ast::is_thread_safe () const noexcept { return false; }
 
bool Ast::is_verbatim () const noexcept { return false; }
 
bool Ast::is_line_comment () const noexcept { return false; }
 
bool Ast::is_block_comment () const noexcept { return false; }
 
bool Ast::is_ontology_statement () const noexcept { return false; }
 
bool Ast::is_program () const noexcept { return false; }
 
bool Ast::is_nrn_state_block () const noexcept { return false; }
 
bool Ast::is_eigen_newton_solver_block () const noexcept { return false; }
 
bool Ast::is_eigen_linear_solver_block () const noexcept { return false; }
 
bool Ast::is_matexp_block () const noexcept { return false; }
 
bool Ast::is_cvode_block () const noexcept { return false; }
 
bool Ast::is_longitudinal_diffusion_block () const noexcept { return false; }
 
bool Ast::is_wrapped_expression () const noexcept { return false; }
 
bool Ast::is_derivimplicit_callback () const noexcept { return false; }
 
bool Ast::is_solution_expression () const noexcept { return false; }
 
bool Ast::is_update_dt () const noexcept { return false; }
 
 
Ast* Ast::get_parent() const {
    return parent;
}
 
void Ast::set_parent(Ast* p) {
    parent = p;
}
 
 
 
    ///
    /// Node member functions definition
    ///
 
 
    void Node::visit_children(visitor::Visitor& v) {
    }
 
    void Node::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Node::accept(visitor::Visitor& v) {
        v.visit_node(*this);
    }
 
    void Node::accept(visitor::ConstVisitor& v) const {
        v.visit_node(*this);
    }
 
 
 
 
    ///
    /// Statement member functions definition
    ///
 
 
    void Statement::visit_children(visitor::Visitor& v) {
    }
 
    void Statement::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Statement::accept(visitor::Visitor& v) {
        v.visit_statement(*this);
    }
 
    void Statement::accept(visitor::ConstVisitor& v) const {
        v.visit_statement(*this);
    }
 
 
 
 
    ///
    /// Expression member functions definition
    ///
 
 
    void Expression::visit_children(visitor::Visitor& v) {
    }
 
    void Expression::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Expression::accept(visitor::Visitor& v) {
        v.visit_expression(*this);
    }
 
    void Expression::accept(visitor::ConstVisitor& v) const {
        v.visit_expression(*this);
    }
 
 
 
 
    ///
    /// Block member functions definition
    ///
 
 
    void Block::visit_children(visitor::Visitor& v) {
    }
 
    void Block::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Block::accept(visitor::Visitor& v) {
        v.visit_block(*this);
    }
 
    void Block::accept(visitor::ConstVisitor& v) const {
        v.visit_block(*this);
    }
 
 
 
 
    ///
    /// Identifier member functions definition
    ///
 
 
    void Identifier::visit_children(visitor::Visitor& v) {
    }
 
    void Identifier::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Identifier::accept(visitor::Visitor& v) {
        v.visit_identifier(*this);
    }
 
    void Identifier::accept(visitor::ConstVisitor& v) const {
        v.visit_identifier(*this);
    }
 
 
 
 
    ///
    /// Number member functions definition
    ///
 
 
    void Number::visit_children(visitor::Visitor& v) {
    }
 
    void Number::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Number::accept(visitor::Visitor& v) {
        v.visit_number(*this);
    }
 
    void Number::accept(visitor::ConstVisitor& v) const {
        v.visit_number(*this);
    }
 
 
 
 
    ///
    /// String member functions definition
    ///
 
      
 
      
 
    void String::visit_children(visitor::Visitor& v) {
    }
 
    void String::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void String::accept(visitor::Visitor& v) {
        v.visit_string(*this);
    }
 
    void String::accept(visitor::ConstVisitor& v) const {
        v.visit_string(*this);
    }
 
 
    String::String(const std::string& value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    String::String(const String& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void String::set_parent_in_children() {
 
 
    }
 
 
    
                       void String::set_value(std::string value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// Integer member functions definition
    ///
 
      
 
      
      
 
      
 
    void Integer::visit_children(visitor::Visitor& v) {
        /// optional member could be nullptr
        if (this->macro) {
            this->macro->accept(v);
        }
        (void)v;
    }
 
    void Integer::visit_children(visitor::ConstVisitor& v) const {
        /// optional member could be nullptr
        if (this->macro) {
            this->macro->accept(v);
        }
        (void)v;
    }
 
    void Integer::accept(visitor::Visitor& v) {
        v.visit_integer(*this);
    }
 
    void Integer::accept(visitor::ConstVisitor& v) const {
        v.visit_integer(*this);
    }
 
 
    Integer::Integer(int value, Name* macro)
                : value(value), macro(macro) { set_parent_in_children(); }
 
 
        Integer::Integer(int value, std::shared_ptr<Name> macro)
                : value(value), macro(macro) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Integer::Integer(const Integer& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
            /// pointer member must be reseted with the new copy
            if (obj.macro) {
                this->macro.reset(obj.macro->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Integer::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (macro) {
                macro->set_parent(this);
            }
 
    }
 
 
    
                       void Integer::set_value(int value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
    
                       void Integer::set_macro(std::shared_ptr<Name>&& macro) {
                           this->macro = macro;
                           // set parents
                           if (macro) {
                               macro->set_parent(this);
                           }
                       }
 
                       void Integer::set_macro(const std::shared_ptr<Name>& macro) {
                           this->macro = macro;
                           // set parents
                           if (macro) {
                               macro->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Float member functions definition
    ///
 
      
 
      
 
    void Float::visit_children(visitor::Visitor& v) {
    }
 
    void Float::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Float::accept(visitor::Visitor& v) {
        v.visit_float(*this);
    }
 
    void Float::accept(visitor::ConstVisitor& v) const {
        v.visit_float(*this);
    }
 
 
    Float::Float(const std::string& value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Float::Float(const Float& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Float::set_parent_in_children() {
 
 
    }
 
 
    
                       void Float::set_value(std::string value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// Double member functions definition
    ///
 
      
 
      
 
    void Double::visit_children(visitor::Visitor& v) {
    }
 
    void Double::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Double::accept(visitor::Visitor& v) {
        v.visit_double(*this);
    }
 
    void Double::accept(visitor::ConstVisitor& v) const {
        v.visit_double(*this);
    }
 
 
    Double::Double(const std::string& value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Double::Double(const Double& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Double::set_parent_in_children() {
 
 
    }
 
 
    
                       void Double::set_value(std::string value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// Boolean member functions definition
    ///
 
      
 
      
 
    void Boolean::visit_children(visitor::Visitor& v) {
    }
 
    void Boolean::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void Boolean::accept(visitor::Visitor& v) {
        v.visit_boolean(*this);
    }
 
    void Boolean::accept(visitor::ConstVisitor& v) const {
        v.visit_boolean(*this);
    }
 
 
    Boolean::Boolean(int value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Boolean::Boolean(const Boolean& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Boolean::set_parent_in_children() {
 
 
    }
 
 
    
                       void Boolean::set_value(int value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// Name member functions definition
    ///
 
      
 
      std::string Name::get_node_name() const {
                             return value->eval();
                         }
 
    void Name::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Name::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Name::accept(visitor::Visitor& v) {
        v.visit_name(*this);
    }
 
    void Name::accept(visitor::ConstVisitor& v) const {
        v.visit_name(*this);
    }
 
 
    Name::Name(String* value)
                : value(value) { set_parent_in_children(); }
 
 
        Name::Name(std::shared_ptr<String> value)
                : value(value) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Name::Name(const Name& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
    void Name::set_name(const std::string& name) {
        value->set(name);
    }
 
    /// set this parent in the children
    void Name::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
 
    }
 
 
    
                       void Name::set_value(std::shared_ptr<String>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void Name::set_value(const std::shared_ptr<String>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// PrimeName member functions definition
    ///
 
      
 
      std::string PrimeName::get_node_name() const {
                             return value->eval();
                         }
      
 
      
 
    void PrimeName::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
        /// use -> for pointer member
        order->accept(v);
        (void)v;
    }
 
    void PrimeName::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
        /// use -> for pointer member
        order->accept(v);
        (void)v;
    }
 
    void PrimeName::accept(visitor::Visitor& v) {
        v.visit_prime_name(*this);
    }
 
    void PrimeName::accept(visitor::ConstVisitor& v) const {
        v.visit_prime_name(*this);
    }
 
 
    PrimeName::PrimeName(String* value, Integer* order)
                : value(value), order(order) { set_parent_in_children(); }
 
 
        PrimeName::PrimeName(std::shared_ptr<String> value, std::shared_ptr<Integer> order)
                : value(value), order(order) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    PrimeName::PrimeName(const PrimeName& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.order) {
                this->order.reset(obj.order->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void PrimeName::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
            /// optional member could be nullptr
            if (order) {
                order->set_parent(this);
            }
 
    }
 
 
    
                       void PrimeName::set_value(std::shared_ptr<String>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void PrimeName::set_value(const std::shared_ptr<String>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
    
                       void PrimeName::set_order(std::shared_ptr<Integer>&& order) {
                           this->order = order;
                           // set parents
                           if (order) {
                               order->set_parent(this);
                           }
                       }
 
                       void PrimeName::set_order(const std::shared_ptr<Integer>& order) {
                           this->order = order;
                           // set parents
                           if (order) {
                               order->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// IndexedName member functions definition
    ///
 
      
 
      std::string IndexedName::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
 
    void IndexedName::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        length->accept(v);
        (void)v;
    }
 
    void IndexedName::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        length->accept(v);
        (void)v;
    }
 
    void IndexedName::accept(visitor::Visitor& v) {
        v.visit_indexed_name(*this);
    }
 
    void IndexedName::accept(visitor::ConstVisitor& v) const {
        v.visit_indexed_name(*this);
    }
 
 
    IndexedName::IndexedName(Identifier* name, Expression* length)
                : name(name), length(length) { set_parent_in_children(); }
 
 
        IndexedName::IndexedName(std::shared_ptr<Identifier> name, std::shared_ptr<Expression> length)
                : name(name), length(length) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    IndexedName::IndexedName(const IndexedName& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.length) {
                this->length.reset(obj.length->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void IndexedName::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (length) {
                length->set_parent(this);
            }
 
    }
 
 
    
                       void IndexedName::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void IndexedName::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void IndexedName::set_length(std::shared_ptr<Expression>&& length) {
                           this->length = length;
                           // set parents
                           if (length) {
                               length->set_parent(this);
                           }
                       }
 
                       void IndexedName::set_length(const std::shared_ptr<Expression>& length) {
                           this->length = length;
                           // set parents
                           if (length) {
                               length->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// VarName member functions definition
    ///
 
      
 
      std::string VarName::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void VarName::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->at) {
            this->at->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->index) {
            this->index->accept(v);
        }
        (void)v;
    }
 
    void VarName::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->at) {
            this->at->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->index) {
            this->index->accept(v);
        }
        (void)v;
    }
 
    void VarName::accept(visitor::Visitor& v) {
        v.visit_var_name(*this);
    }
 
    void VarName::accept(visitor::ConstVisitor& v) const {
        v.visit_var_name(*this);
    }
 
 
    VarName::VarName(Identifier* name, Integer* at, Expression* index)
                : name(name), at(at), index(index) { set_parent_in_children(); }
 
 
        VarName::VarName(std::shared_ptr<Identifier> name, std::shared_ptr<Integer> at, std::shared_ptr<Expression> index)
                : name(name), at(at), index(index) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    VarName::VarName(const VarName& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.at) {
                this->at.reset(obj.at->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.index) {
                this->index.reset(obj.index->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void VarName::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (at) {
                at->set_parent(this);
            }
            /// optional member could be nullptr
            if (index) {
                index->set_parent(this);
            }
 
    }
 
 
    
                       void VarName::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void VarName::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void VarName::set_at(std::shared_ptr<Integer>&& at) {
                           this->at = at;
                           // set parents
                           if (at) {
                               at->set_parent(this);
                           }
                       }
 
                       void VarName::set_at(const std::shared_ptr<Integer>& at) {
                           this->at = at;
                           // set parents
                           if (at) {
                               at->set_parent(this);
                           }
                       }
                    
    
                       void VarName::set_index(std::shared_ptr<Expression>&& index) {
                           this->index = index;
                           // set parents
                           if (index) {
                               index->set_parent(this);
                           }
                       }
 
                       void VarName::set_index(const std::shared_ptr<Expression>& index) {
                           this->index = index;
                           // set parents
                           if (index) {
                               index->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Argument member functions definition
    ///
 
      
 
      std::string Argument::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
 
    void Argument::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void Argument::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void Argument::accept(visitor::Visitor& v) {
        v.visit_argument(*this);
    }
 
    void Argument::accept(visitor::ConstVisitor& v) const {
        v.visit_argument(*this);
    }
 
 
    Argument::Argument(Identifier* name, Unit* unit)
                : name(name), unit(unit) { set_parent_in_children(); }
 
 
        Argument::Argument(std::shared_ptr<Identifier> name, std::shared_ptr<Unit> unit)
                : name(name), unit(unit) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Argument::Argument(const Argument& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Argument::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
 
    }
 
 
    
                       void Argument::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void Argument::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void Argument::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void Argument::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ReactVarName member functions definition
    ///
 
      
 
      
      
 
      std::string ReactVarName::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void ReactVarName::visit_children(visitor::Visitor& v) {
        /// optional member could be nullptr
        if (this->value) {
            this->value->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ReactVarName::visit_children(visitor::ConstVisitor& v) const {
        /// optional member could be nullptr
        if (this->value) {
            this->value->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ReactVarName::accept(visitor::Visitor& v) {
        v.visit_react_var_name(*this);
    }
 
    void ReactVarName::accept(visitor::ConstVisitor& v) const {
        v.visit_react_var_name(*this);
    }
 
 
    ReactVarName::ReactVarName(Integer* value, VarName* name)
                : value(value), name(name) { set_parent_in_children(); }
 
 
        ReactVarName::ReactVarName(std::shared_ptr<Integer> value, std::shared_ptr<VarName> name)
                : value(value), name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ReactVarName::ReactVarName(const ReactVarName& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ReactVarName::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void ReactVarName::set_value(std::shared_ptr<Integer>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void ReactVarName::set_value(const std::shared_ptr<Integer>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
    
                       void ReactVarName::set_name(std::shared_ptr<VarName>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ReactVarName::set_name(const std::shared_ptr<VarName>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ReadIonVar member functions definition
    ///
 
      
 
      std::string ReadIonVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void ReadIonVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ReadIonVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ReadIonVar::accept(visitor::Visitor& v) {
        v.visit_read_ion_var(*this);
    }
 
    void ReadIonVar::accept(visitor::ConstVisitor& v) const {
        v.visit_read_ion_var(*this);
    }
 
 
    ReadIonVar::ReadIonVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        ReadIonVar::ReadIonVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ReadIonVar::ReadIonVar(const ReadIonVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ReadIonVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void ReadIonVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ReadIonVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// WriteIonVar member functions definition
    ///
 
      
 
      std::string WriteIonVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void WriteIonVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void WriteIonVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void WriteIonVar::accept(visitor::Visitor& v) {
        v.visit_write_ion_var(*this);
    }
 
    void WriteIonVar::accept(visitor::ConstVisitor& v) const {
        v.visit_write_ion_var(*this);
    }
 
 
    WriteIonVar::WriteIonVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        WriteIonVar::WriteIonVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    WriteIonVar::WriteIonVar(const WriteIonVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void WriteIonVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void WriteIonVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void WriteIonVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// NonspecificCurVar member functions definition
    ///
 
      
 
      std::string NonspecificCurVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void NonspecificCurVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void NonspecificCurVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void NonspecificCurVar::accept(visitor::Visitor& v) {
        v.visit_nonspecific_cur_var(*this);
    }
 
    void NonspecificCurVar::accept(visitor::ConstVisitor& v) const {
        v.visit_nonspecific_cur_var(*this);
    }
 
 
    NonspecificCurVar::NonspecificCurVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        NonspecificCurVar::NonspecificCurVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    NonspecificCurVar::NonspecificCurVar(const NonspecificCurVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NonspecificCurVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void NonspecificCurVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void NonspecificCurVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ElectrodeCurVar member functions definition
    ///
 
      
 
      std::string ElectrodeCurVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void ElectrodeCurVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ElectrodeCurVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ElectrodeCurVar::accept(visitor::Visitor& v) {
        v.visit_electrode_cur_var(*this);
    }
 
    void ElectrodeCurVar::accept(visitor::ConstVisitor& v) const {
        v.visit_electrode_cur_var(*this);
    }
 
 
    ElectrodeCurVar::ElectrodeCurVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        ElectrodeCurVar::ElectrodeCurVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ElectrodeCurVar::ElectrodeCurVar(const ElectrodeCurVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ElectrodeCurVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void ElectrodeCurVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ElectrodeCurVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// RangeVar member functions definition
    ///
 
      
 
      std::string RangeVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void RangeVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void RangeVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void RangeVar::accept(visitor::Visitor& v) {
        v.visit_range_var(*this);
    }
 
    void RangeVar::accept(visitor::ConstVisitor& v) const {
        v.visit_range_var(*this);
    }
 
 
    RangeVar::RangeVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        RangeVar::RangeVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    RangeVar::RangeVar(const RangeVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void RangeVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void RangeVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void RangeVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// GlobalVar member functions definition
    ///
 
      
 
      std::string GlobalVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void GlobalVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void GlobalVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void GlobalVar::accept(visitor::Visitor& v) {
        v.visit_global_var(*this);
    }
 
    void GlobalVar::accept(visitor::ConstVisitor& v) const {
        v.visit_global_var(*this);
    }
 
 
    GlobalVar::GlobalVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        GlobalVar::GlobalVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    GlobalVar::GlobalVar(const GlobalVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void GlobalVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void GlobalVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void GlobalVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// PointerVar member functions definition
    ///
 
      
 
      std::string PointerVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void PointerVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void PointerVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void PointerVar::accept(visitor::Visitor& v) {
        v.visit_pointer_var(*this);
    }
 
    void PointerVar::accept(visitor::ConstVisitor& v) const {
        v.visit_pointer_var(*this);
    }
 
 
    PointerVar::PointerVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        PointerVar::PointerVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    PointerVar::PointerVar(const PointerVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void PointerVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void PointerVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void PointerVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// RandomVar member functions definition
    ///
 
      
 
      std::string RandomVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void RandomVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void RandomVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void RandomVar::accept(visitor::Visitor& v) {
        v.visit_random_var(*this);
    }
 
    void RandomVar::accept(visitor::ConstVisitor& v) const {
        v.visit_random_var(*this);
    }
 
 
    RandomVar::RandomVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        RandomVar::RandomVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    RandomVar::RandomVar(const RandomVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void RandomVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void RandomVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void RandomVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BbcorePointerVar member functions definition
    ///
 
      
 
      std::string BbcorePointerVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void BbcorePointerVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void BbcorePointerVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void BbcorePointerVar::accept(visitor::Visitor& v) {
        v.visit_bbcore_pointer_var(*this);
    }
 
    void BbcorePointerVar::accept(visitor::ConstVisitor& v) const {
        v.visit_bbcore_pointer_var(*this);
    }
 
 
    BbcorePointerVar::BbcorePointerVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        BbcorePointerVar::BbcorePointerVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    BbcorePointerVar::BbcorePointerVar(const BbcorePointerVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BbcorePointerVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void BbcorePointerVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void BbcorePointerVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ExternVar member functions definition
    ///
 
      
 
      std::string ExternVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void ExternVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ExternVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void ExternVar::accept(visitor::Visitor& v) {
        v.visit_extern_var(*this);
    }
 
    void ExternVar::accept(visitor::ConstVisitor& v) const {
        v.visit_extern_var(*this);
    }
 
 
    ExternVar::ExternVar(Name* name)
                : name(name) { set_parent_in_children(); }
 
 
        ExternVar::ExternVar(std::shared_ptr<Name> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ExternVar::ExternVar(const ExternVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ExternVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void ExternVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ExternVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ParamBlock member functions definition
    ///
 
      
 
      
 
    void ParamBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void ParamBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void ParamBlock::accept(visitor::Visitor& v) {
        v.visit_param_block(*this);
    }
 
    void ParamBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_param_block(*this);
    }
 
 
    ParamBlock::ParamBlock(const ParamAssignVector& statements)
                : statements(statements) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    ParamBlock::ParamBlock(const ParamBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.statements) {
                this->statements.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ParamBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : statements) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void ParamBlock::set_statements(ParamAssignVector&& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void ParamBlock::set_statements(const ParamAssignVector& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// IndependentBlock member functions definition
    ///
 
      
 
      
 
    void IndependentBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void IndependentBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void IndependentBlock::accept(visitor::Visitor& v) {
        v.visit_independent_block(*this);
    }
 
    void IndependentBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_independent_block(*this);
    }
 
 
    IndependentBlock::IndependentBlock(const NameVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    IndependentBlock::IndependentBlock(const IndependentBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void IndependentBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void IndependentBlock::set_variables(NameVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void IndependentBlock::set_variables(const NameVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// AssignedBlock member functions definition
    ///
 
      
/**
 * \brief Add member to definitions by raw pointer
 */
void AssignedBlock::emplace_back_assigned_definition(AssignedDefinition *n) {
   definitions.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to definitions by shared_ptr
 */
void AssignedBlock::emplace_back_assigned_definition(std::shared_ptr<AssignedDefinition> n) {
   definitions.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to definitions
 */
AssignedDefinitionVector::const_iterator AssignedBlock::erase_assigned_definition(AssignedDefinitionVector::const_iterator first) {
   return definitions.erase(first);
}
/**
 * \brief Erase members to definitions
 */
AssignedDefinitionVector::const_iterator AssignedBlock::erase_assigned_definition(AssignedDefinitionVector::const_iterator first, AssignedDefinitionVector::const_iterator last) {
   return definitions.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to definitions
 *
 * loosely following the cpp reference of remove_if
 */
size_t AssignedBlock::erase_assigned_definition(std::unordered_set<AssignedDefinition*>& to_be_erased) {
   auto first = definitions.begin();
   auto last = definitions.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_assigned_definition(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_assigned_definition(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to definitions
 */
AssignedDefinitionVector::const_iterator AssignedBlock::insert_assigned_definition(AssignedDefinitionVector::const_iterator position, const std::shared_ptr<AssignedDefinition>& n) {
    n->set_parent(this); 
   return definitions.insert(position, n);
}
 
/**
 * \brief Reset member to definitions
 */
void AssignedBlock::reset_assigned_definition(AssignedDefinitionVector::const_iterator position, AssignedDefinition* n) {
    //set parents
    n->set_parent(this); 
 
   definitions[position - definitions.begin()].reset(n);
}
 
/**
 * \brief Reset member to definitions
 */
void AssignedBlock::reset_assigned_definition(AssignedDefinitionVector::const_iterator position, std::shared_ptr<AssignedDefinition> n) {
    //set parents
    n->set_parent(this); 
 
   definitions[position - definitions.begin()] = n;
}
 
 
      
 
    void AssignedBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->definitions) {
            item->accept(v);
        }
        (void)v;
    }
 
    void AssignedBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->definitions) {
            item->accept(v);
        }
        (void)v;
    }
 
    void AssignedBlock::accept(visitor::Visitor& v) {
        v.visit_assigned_block(*this);
    }
 
    void AssignedBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_assigned_block(*this);
    }
 
 
    AssignedBlock::AssignedBlock(const AssignedDefinitionVector& definitions)
                : definitions(definitions) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    AssignedBlock::AssignedBlock(const AssignedBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.definitions) {
                this->definitions.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void AssignedBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : definitions) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void AssignedBlock::set_definitions(AssignedDefinitionVector&& definitions) {
                           this->definitions = definitions;
                           // set parents
                           for (auto& ii : definitions) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void AssignedBlock::set_definitions(const AssignedDefinitionVector& definitions) {
                           this->definitions = definitions;
                           // set parents
                           for (auto& ii : definitions) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// StateBlock member functions definition
    ///
 
      
 
      
 
    void StateBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->definitions) {
            item->accept(v);
        }
        (void)v;
    }
 
    void StateBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->definitions) {
            item->accept(v);
        }
        (void)v;
    }
 
    void StateBlock::accept(visitor::Visitor& v) {
        v.visit_state_block(*this);
    }
 
    void StateBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_state_block(*this);
    }
 
 
    StateBlock::StateBlock(const AssignedDefinitionVector& definitions)
                : definitions(definitions) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    StateBlock::StateBlock(const StateBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.definitions) {
                this->definitions.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void StateBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : definitions) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void StateBlock::set_definitions(AssignedDefinitionVector&& definitions) {
                           this->definitions = definitions;
                           // set parents
                           for (auto& ii : definitions) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void StateBlock::set_definitions(const AssignedDefinitionVector& definitions) {
                           this->definitions = definitions;
                           // set parents
                           for (auto& ii : definitions) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// InitialBlock member functions definition
    ///
 
      
 
      
 
    void InitialBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void InitialBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void InitialBlock::accept(visitor::Visitor& v) {
        v.visit_initial_block(*this);
    }
 
    void InitialBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_initial_block(*this);
    }
 
 
    InitialBlock::InitialBlock(StatementBlock* statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
        InitialBlock::InitialBlock(std::shared_ptr<StatementBlock> statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    InitialBlock::InitialBlock(const InitialBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void InitialBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void InitialBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void InitialBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ConstructorBlock member functions definition
    ///
 
      
 
      
 
    void ConstructorBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ConstructorBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ConstructorBlock::accept(visitor::Visitor& v) {
        v.visit_constructor_block(*this);
    }
 
    void ConstructorBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_constructor_block(*this);
    }
 
 
    ConstructorBlock::ConstructorBlock(StatementBlock* statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
        ConstructorBlock::ConstructorBlock(std::shared_ptr<StatementBlock> statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ConstructorBlock::ConstructorBlock(const ConstructorBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ConstructorBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void ConstructorBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void ConstructorBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// DestructorBlock member functions definition
    ///
 
      
 
      
 
    void DestructorBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void DestructorBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void DestructorBlock::accept(visitor::Visitor& v) {
        v.visit_destructor_block(*this);
    }
 
    void DestructorBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_destructor_block(*this);
    }
 
 
    DestructorBlock::DestructorBlock(StatementBlock* statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
        DestructorBlock::DestructorBlock(std::shared_ptr<StatementBlock> statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    DestructorBlock::DestructorBlock(const DestructorBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void DestructorBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void DestructorBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void DestructorBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// StatementBlock member functions definition
    ///
 
      
/**
 * \brief Add member to statements by raw pointer
 */
void StatementBlock::emplace_back_statement(Statement *n) {
   statements.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to statements by shared_ptr
 */
void StatementBlock::emplace_back_statement(std::shared_ptr<Statement> n) {
   statements.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to statements
 */
StatementVector::const_iterator StatementBlock::erase_statement(StatementVector::const_iterator first) {
   return statements.erase(first);
}
/**
 * \brief Erase members to statements
 */
StatementVector::const_iterator StatementBlock::erase_statement(StatementVector::const_iterator first, StatementVector::const_iterator last) {
   return statements.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to statements
 *
 * loosely following the cpp reference of remove_if
 */
size_t StatementBlock::erase_statement(std::unordered_set<Statement*>& to_be_erased) {
   auto first = statements.begin();
   auto last = statements.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_statement(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_statement(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to statements
 */
StatementVector::const_iterator StatementBlock::insert_statement(StatementVector::const_iterator position, const std::shared_ptr<Statement>& n) {
    n->set_parent(this); 
   return statements.insert(position, n);
}
 
/**
 * \brief Reset member to statements
 */
void StatementBlock::reset_statement(StatementVector::const_iterator position, Statement* n) {
    //set parents
    n->set_parent(this); 
 
   statements[position - statements.begin()].reset(n);
}
 
/**
 * \brief Reset member to statements
 */
void StatementBlock::reset_statement(StatementVector::const_iterator position, std::shared_ptr<Statement> n) {
    //set parents
    n->set_parent(this); 
 
   statements[position - statements.begin()] = n;
}
 
 
      
 
    void StatementBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void StatementBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void StatementBlock::accept(visitor::Visitor& v) {
        v.visit_statement_block(*this);
    }
 
    void StatementBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_statement_block(*this);
    }
 
 
    StatementBlock::StatementBlock(const StatementVector& statements)
                : statements(statements) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    StatementBlock::StatementBlock(const StatementBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.statements) {
                this->statements.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void StatementBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : statements) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void StatementBlock::set_statements(StatementVector&& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void StatementBlock::set_statements(const StatementVector& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// DerivativeBlock member functions definition
    ///
 
      
 
      std::string DerivativeBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
 
    void DerivativeBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void DerivativeBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void DerivativeBlock::accept(visitor::Visitor& v) {
        v.visit_derivative_block(*this);
    }
 
    void DerivativeBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_derivative_block(*this);
    }
 
 
    DerivativeBlock::DerivativeBlock(Name* name, StatementBlock* statement_block)
                : name(name), statement_block(statement_block) { set_parent_in_children(); }
 
 
        DerivativeBlock::DerivativeBlock(std::shared_ptr<Name> name, std::shared_ptr<StatementBlock> statement_block)
                : name(name), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    DerivativeBlock::DerivativeBlock(const DerivativeBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void DerivativeBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void DerivativeBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void DerivativeBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void DerivativeBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void DerivativeBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// LinearBlock member functions definition
    ///
 
      
 
      std::string LinearBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void LinearBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->solvefor) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void LinearBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->solvefor) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void LinearBlock::accept(visitor::Visitor& v) {
        v.visit_linear_block(*this);
    }
 
    void LinearBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_linear_block(*this);
    }
 
 
    LinearBlock::LinearBlock(Name* name, const NameVector& solvefor, StatementBlock* statement_block)
                : name(name), solvefor(solvefor), statement_block(statement_block) { set_parent_in_children(); }
 
 
        LinearBlock::LinearBlock(std::shared_ptr<Name> name, const NameVector& solvefor, std::shared_ptr<StatementBlock> statement_block)
                : name(name), solvefor(solvefor), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LinearBlock::LinearBlock(const LinearBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.solvefor) {
                this->solvefor.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LinearBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : solvefor) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void LinearBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void LinearBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void LinearBlock::set_solvefor(NameVector&& solvefor) {
                           this->solvefor = solvefor;
                           // set parents
                           for (auto& ii : solvefor) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void LinearBlock::set_solvefor(const NameVector& solvefor) {
                           this->solvefor = solvefor;
                           // set parents
                           for (auto& ii : solvefor) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void LinearBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void LinearBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// NonLinearBlock member functions definition
    ///
 
      
 
      std::string NonLinearBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void NonLinearBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->solvefor) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void NonLinearBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->solvefor) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void NonLinearBlock::accept(visitor::Visitor& v) {
        v.visit_non_linear_block(*this);
    }
 
    void NonLinearBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_non_linear_block(*this);
    }
 
 
    NonLinearBlock::NonLinearBlock(Name* name, const NameVector& solvefor, StatementBlock* statement_block)
                : name(name), solvefor(solvefor), statement_block(statement_block) { set_parent_in_children(); }
 
 
        NonLinearBlock::NonLinearBlock(std::shared_ptr<Name> name, const NameVector& solvefor, std::shared_ptr<StatementBlock> statement_block)
                : name(name), solvefor(solvefor), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    NonLinearBlock::NonLinearBlock(const NonLinearBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.solvefor) {
                this->solvefor.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NonLinearBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : solvefor) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void NonLinearBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void NonLinearBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void NonLinearBlock::set_solvefor(NameVector&& solvefor) {
                           this->solvefor = solvefor;
                           // set parents
                           for (auto& ii : solvefor) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void NonLinearBlock::set_solvefor(const NameVector& solvefor) {
                           this->solvefor = solvefor;
                           // set parents
                           for (auto& ii : solvefor) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void NonLinearBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void NonLinearBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// DiscreteBlock member functions definition
    ///
 
      
 
      std::string DiscreteBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
 
    void DiscreteBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void DiscreteBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void DiscreteBlock::accept(visitor::Visitor& v) {
        v.visit_discrete_block(*this);
    }
 
    void DiscreteBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_discrete_block(*this);
    }
 
 
    DiscreteBlock::DiscreteBlock(Name* name, StatementBlock* statement_block)
                : name(name), statement_block(statement_block) { set_parent_in_children(); }
 
 
        DiscreteBlock::DiscreteBlock(std::shared_ptr<Name> name, std::shared_ptr<StatementBlock> statement_block)
                : name(name), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    DiscreteBlock::DiscreteBlock(const DiscreteBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void DiscreteBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void DiscreteBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void DiscreteBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void DiscreteBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void DiscreteBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// FunctionTableBlock member functions definition
    ///
 
      
 
      std::string FunctionTableBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void FunctionTableBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void FunctionTableBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void FunctionTableBlock::accept(visitor::Visitor& v) {
        v.visit_function_table_block(*this);
    }
 
    void FunctionTableBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_function_table_block(*this);
    }
 
 
    FunctionTableBlock::FunctionTableBlock(Name* name, const ArgumentVector& parameters, Unit* unit)
                : name(name), parameters(parameters), unit(unit) { set_parent_in_children(); }
 
 
        FunctionTableBlock::FunctionTableBlock(std::shared_ptr<Name> name, const ArgumentVector& parameters, std::shared_ptr<Unit> unit)
                : name(name), parameters(parameters), unit(unit) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    FunctionTableBlock::FunctionTableBlock(const FunctionTableBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.parameters) {
                this->parameters.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void FunctionTableBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : parameters) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
 
    }
 
 
    
                       void FunctionTableBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void FunctionTableBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void FunctionTableBlock::set_parameters(ArgumentVector&& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void FunctionTableBlock::set_parameters(const ArgumentVector& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void FunctionTableBlock::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void FunctionTableBlock::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// FunctionBlock member functions definition
    ///
 
      
 
      std::string FunctionBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
 
    void FunctionBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void FunctionBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void FunctionBlock::accept(visitor::Visitor& v) {
        v.visit_function_block(*this);
    }
 
    void FunctionBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_function_block(*this);
    }
 
 
    FunctionBlock::FunctionBlock(Name* name, const ArgumentVector& parameters, Unit* unit, StatementBlock* statement_block)
                : name(name), parameters(parameters), unit(unit), statement_block(statement_block) { set_parent_in_children(); }
 
 
        FunctionBlock::FunctionBlock(std::shared_ptr<Name> name, const ArgumentVector& parameters, std::shared_ptr<Unit> unit, std::shared_ptr<StatementBlock> statement_block)
                : name(name), parameters(parameters), unit(unit), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    FunctionBlock::FunctionBlock(const FunctionBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.parameters) {
                this->parameters.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void FunctionBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : parameters) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void FunctionBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void FunctionBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void FunctionBlock::set_parameters(ArgumentVector&& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void FunctionBlock::set_parameters(const ArgumentVector& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void FunctionBlock::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void FunctionBlock::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
    
                       void FunctionBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void FunctionBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ProcedureBlock member functions definition
    ///
 
      
 
      std::string ProcedureBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
 
    void ProcedureBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ProcedureBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ProcedureBlock::accept(visitor::Visitor& v) {
        v.visit_procedure_block(*this);
    }
 
    void ProcedureBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_procedure_block(*this);
    }
 
 
    ProcedureBlock::ProcedureBlock(Name* name, const ArgumentVector& parameters, Unit* unit, StatementBlock* statement_block)
                : name(name), parameters(parameters), unit(unit), statement_block(statement_block) { set_parent_in_children(); }
 
 
        ProcedureBlock::ProcedureBlock(std::shared_ptr<Name> name, const ArgumentVector& parameters, std::shared_ptr<Unit> unit, std::shared_ptr<StatementBlock> statement_block)
                : name(name), parameters(parameters), unit(unit), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ProcedureBlock::ProcedureBlock(const ProcedureBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.parameters) {
                this->parameters.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ProcedureBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : parameters) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void ProcedureBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ProcedureBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void ProcedureBlock::set_parameters(ArgumentVector&& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void ProcedureBlock::set_parameters(const ArgumentVector& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void ProcedureBlock::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void ProcedureBlock::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
    
                       void ProcedureBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void ProcedureBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// NetReceiveBlock member functions definition
    ///
 
      
 
      
      
 
      
 
    void NetReceiveBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void NetReceiveBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void NetReceiveBlock::accept(visitor::Visitor& v) {
        v.visit_net_receive_block(*this);
    }
 
    void NetReceiveBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_net_receive_block(*this);
    }
 
 
    NetReceiveBlock::NetReceiveBlock(const ArgumentVector& parameters, StatementBlock* statement_block)
                : parameters(parameters), statement_block(statement_block) { set_parent_in_children(); }
 
 
        NetReceiveBlock::NetReceiveBlock(const ArgumentVector& parameters, std::shared_ptr<StatementBlock> statement_block)
                : parameters(parameters), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    NetReceiveBlock::NetReceiveBlock(const NetReceiveBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.parameters) {
                this->parameters.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NetReceiveBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : parameters) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void NetReceiveBlock::set_parameters(ArgumentVector&& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void NetReceiveBlock::set_parameters(const ArgumentVector& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void NetReceiveBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void NetReceiveBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// SolveBlock member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
 
    void SolveBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        block_name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->method) {
            this->method->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->steadystate) {
            this->steadystate->accept(v);
        }
        (void)v;
    }
 
    void SolveBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        block_name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->method) {
            this->method->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->steadystate) {
            this->steadystate->accept(v);
        }
        (void)v;
    }
 
    void SolveBlock::accept(visitor::Visitor& v) {
        v.visit_solve_block(*this);
    }
 
    void SolveBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_solve_block(*this);
    }
 
 
    SolveBlock::SolveBlock(Name* block_name, Name* method, Name* steadystate)
                : block_name(block_name), method(method), steadystate(steadystate) { set_parent_in_children(); }
 
 
        SolveBlock::SolveBlock(std::shared_ptr<Name> block_name, std::shared_ptr<Name> method, std::shared_ptr<Name> steadystate)
                : block_name(block_name), method(method), steadystate(steadystate) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    SolveBlock::SolveBlock(const SolveBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.block_name) {
                this->block_name.reset(obj.block_name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.method) {
                this->method.reset(obj.method->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.steadystate) {
                this->steadystate.reset(obj.steadystate->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void SolveBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (block_name) {
                block_name->set_parent(this);
            }
            /// optional member could be nullptr
            if (method) {
                method->set_parent(this);
            }
            /// optional member could be nullptr
            if (steadystate) {
                steadystate->set_parent(this);
            }
 
    }
 
 
    
                       void SolveBlock::set_block_name(std::shared_ptr<Name>&& block_name) {
                           this->block_name = block_name;
                           // set parents
                           if (block_name) {
                               block_name->set_parent(this);
                           }
                       }
 
                       void SolveBlock::set_block_name(const std::shared_ptr<Name>& block_name) {
                           this->block_name = block_name;
                           // set parents
                           if (block_name) {
                               block_name->set_parent(this);
                           }
                       }
                    
    
                       void SolveBlock::set_method(std::shared_ptr<Name>&& method) {
                           this->method = method;
                           // set parents
                           if (method) {
                               method->set_parent(this);
                           }
                       }
 
                       void SolveBlock::set_method(const std::shared_ptr<Name>& method) {
                           this->method = method;
                           // set parents
                           if (method) {
                               method->set_parent(this);
                           }
                       }
                    
    
                       void SolveBlock::set_steadystate(std::shared_ptr<Name>&& steadystate) {
                           this->steadystate = steadystate;
                           // set parents
                           if (steadystate) {
                               steadystate->set_parent(this);
                           }
                       }
 
                       void SolveBlock::set_steadystate(const std::shared_ptr<Name>& steadystate) {
                           this->steadystate = steadystate;
                           // set parents
                           if (steadystate) {
                               steadystate->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BreakpointBlock member functions definition
    ///
 
      
 
      
 
    void BreakpointBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void BreakpointBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void BreakpointBlock::accept(visitor::Visitor& v) {
        v.visit_breakpoint_block(*this);
    }
 
    void BreakpointBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_breakpoint_block(*this);
    }
 
 
    BreakpointBlock::BreakpointBlock(StatementBlock* statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
        BreakpointBlock::BreakpointBlock(std::shared_ptr<StatementBlock> statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    BreakpointBlock::BreakpointBlock(const BreakpointBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BreakpointBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void BreakpointBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void BreakpointBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BeforeBlock member functions definition
    ///
 
      
 
      
 
    void BeforeBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        bablock->accept(v);
        (void)v;
    }
 
    void BeforeBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        bablock->accept(v);
        (void)v;
    }
 
    void BeforeBlock::accept(visitor::Visitor& v) {
        v.visit_before_block(*this);
    }
 
    void BeforeBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_before_block(*this);
    }
 
 
    BeforeBlock::BeforeBlock(BABlock* bablock)
                : bablock(bablock) { set_parent_in_children(); }
 
 
        BeforeBlock::BeforeBlock(std::shared_ptr<BABlock> bablock)
                : bablock(bablock) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    BeforeBlock::BeforeBlock(const BeforeBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.bablock) {
                this->bablock.reset(obj.bablock->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BeforeBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (bablock) {
                bablock->set_parent(this);
            }
 
    }
 
 
    
                       void BeforeBlock::set_bablock(std::shared_ptr<BABlock>&& bablock) {
                           this->bablock = bablock;
                           // set parents
                           if (bablock) {
                               bablock->set_parent(this);
                           }
                       }
 
                       void BeforeBlock::set_bablock(const std::shared_ptr<BABlock>& bablock) {
                           this->bablock = bablock;
                           // set parents
                           if (bablock) {
                               bablock->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// AfterBlock member functions definition
    ///
 
      
 
      
 
    void AfterBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        bablock->accept(v);
        (void)v;
    }
 
    void AfterBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        bablock->accept(v);
        (void)v;
    }
 
    void AfterBlock::accept(visitor::Visitor& v) {
        v.visit_after_block(*this);
    }
 
    void AfterBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_after_block(*this);
    }
 
 
    AfterBlock::AfterBlock(BABlock* bablock)
                : bablock(bablock) { set_parent_in_children(); }
 
 
        AfterBlock::AfterBlock(std::shared_ptr<BABlock> bablock)
                : bablock(bablock) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    AfterBlock::AfterBlock(const AfterBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.bablock) {
                this->bablock.reset(obj.bablock->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void AfterBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (bablock) {
                bablock->set_parent(this);
            }
 
    }
 
 
    
                       void AfterBlock::set_bablock(std::shared_ptr<BABlock>&& bablock) {
                           this->bablock = bablock;
                           // set parents
                           if (bablock) {
                               bablock->set_parent(this);
                           }
                       }
 
                       void AfterBlock::set_bablock(const std::shared_ptr<BABlock>& bablock) {
                           this->bablock = bablock;
                           // set parents
                           if (bablock) {
                               bablock->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BABlock member functions definition
    ///
 
      
 
      
      
 
      
 
    void BABlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        type->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void BABlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        type->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void BABlock::accept(visitor::Visitor& v) {
        v.visit_ba_block(*this);
    }
 
    void BABlock::accept(visitor::ConstVisitor& v) const {
        v.visit_ba_block(*this);
    }
 
 
    BABlock::BABlock(BABlockType* type, StatementBlock* statement_block)
                : type(type), statement_block(statement_block) { set_parent_in_children(); }
 
 
        BABlock::BABlock(std::shared_ptr<BABlockType> type, std::shared_ptr<StatementBlock> statement_block)
                : type(type), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    BABlock::BABlock(const BABlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.type) {
                this->type.reset(obj.type->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BABlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (type) {
                type->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void BABlock::set_type(std::shared_ptr<BABlockType>&& type) {
                           this->type = type;
                           // set parents
                           if (type) {
                               type->set_parent(this);
                           }
                       }
 
                       void BABlock::set_type(const std::shared_ptr<BABlockType>& type) {
                           this->type = type;
                           // set parents
                           if (type) {
                               type->set_parent(this);
                           }
                       }
                    
    
                       void BABlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void BABlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ForNetcon member functions definition
    ///
 
      
 
      
      
 
      
 
    void ForNetcon::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ForNetcon::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->parameters) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ForNetcon::accept(visitor::Visitor& v) {
        v.visit_for_netcon(*this);
    }
 
    void ForNetcon::accept(visitor::ConstVisitor& v) const {
        v.visit_for_netcon(*this);
    }
 
 
    ForNetcon::ForNetcon(const ArgumentVector& parameters, StatementBlock* statement_block)
                : parameters(parameters), statement_block(statement_block) { set_parent_in_children(); }
 
 
        ForNetcon::ForNetcon(const ArgumentVector& parameters, std::shared_ptr<StatementBlock> statement_block)
                : parameters(parameters), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ForNetcon::ForNetcon(const ForNetcon& obj) {
            /// copy each element of vector
            for (auto& item : obj.parameters) {
                this->parameters.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ForNetcon::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : parameters) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void ForNetcon::set_parameters(ArgumentVector&& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void ForNetcon::set_parameters(const ArgumentVector& parameters) {
                           this->parameters = parameters;
                           // set parents
                           for (auto& ii : parameters) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void ForNetcon::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void ForNetcon::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// KineticBlock member functions definition
    ///
 
      
 
      std::string KineticBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void KineticBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->solvefor) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void KineticBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->solvefor) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void KineticBlock::accept(visitor::Visitor& v) {
        v.visit_kinetic_block(*this);
    }
 
    void KineticBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_kinetic_block(*this);
    }
 
 
    KineticBlock::KineticBlock(Name* name, const NameVector& solvefor, StatementBlock* statement_block)
                : name(name), solvefor(solvefor), statement_block(statement_block) { set_parent_in_children(); }
 
 
        KineticBlock::KineticBlock(std::shared_ptr<Name> name, const NameVector& solvefor, std::shared_ptr<StatementBlock> statement_block)
                : name(name), solvefor(solvefor), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    KineticBlock::KineticBlock(const KineticBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.solvefor) {
                this->solvefor.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void KineticBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : solvefor) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void KineticBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void KineticBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void KineticBlock::set_solvefor(NameVector&& solvefor) {
                           this->solvefor = solvefor;
                           // set parents
                           for (auto& ii : solvefor) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void KineticBlock::set_solvefor(const NameVector& solvefor) {
                           this->solvefor = solvefor;
                           // set parents
                           for (auto& ii : solvefor) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void KineticBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void KineticBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// UnitBlock member functions definition
    ///
 
      
 
      
 
    void UnitBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->definitions) {
            item->accept(v);
        }
        (void)v;
    }
 
    void UnitBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->definitions) {
            item->accept(v);
        }
        (void)v;
    }
 
    void UnitBlock::accept(visitor::Visitor& v) {
        v.visit_unit_block(*this);
    }
 
    void UnitBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_unit_block(*this);
    }
 
 
    UnitBlock::UnitBlock(const ExpressionVector& definitions)
                : definitions(definitions) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    UnitBlock::UnitBlock(const UnitBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.definitions) {
                this->definitions.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void UnitBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : definitions) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void UnitBlock::set_definitions(ExpressionVector&& definitions) {
                           this->definitions = definitions;
                           // set parents
                           for (auto& ii : definitions) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void UnitBlock::set_definitions(const ExpressionVector& definitions) {
                           this->definitions = definitions;
                           // set parents
                           for (auto& ii : definitions) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// ConstantBlock member functions definition
    ///
 
      
 
      
 
    void ConstantBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void ConstantBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void ConstantBlock::accept(visitor::Visitor& v) {
        v.visit_constant_block(*this);
    }
 
    void ConstantBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_constant_block(*this);
    }
 
 
    ConstantBlock::ConstantBlock(const ConstantStatementVector& statements)
                : statements(statements) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    ConstantBlock::ConstantBlock(const ConstantBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.statements) {
                this->statements.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ConstantBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : statements) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void ConstantBlock::set_statements(ConstantStatementVector&& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void ConstantBlock::set_statements(const ConstantStatementVector& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// NeuronBlock member functions definition
    ///
 
      
 
      
 
    void NeuronBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void NeuronBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void NeuronBlock::accept(visitor::Visitor& v) {
        v.visit_neuron_block(*this);
    }
 
    void NeuronBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_neuron_block(*this);
    }
 
 
    NeuronBlock::NeuronBlock(StatementBlock* statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
        NeuronBlock::NeuronBlock(std::shared_ptr<StatementBlock> statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    NeuronBlock::NeuronBlock(const NeuronBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NeuronBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void NeuronBlock::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void NeuronBlock::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Unit member functions definition
    ///
 
      
 
      std::string Unit::get_node_name() const {
                             return name->eval();
                         }
 
    void Unit::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void Unit::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void Unit::accept(visitor::Visitor& v) {
        v.visit_unit(*this);
    }
 
    void Unit::accept(visitor::ConstVisitor& v) const {
        v.visit_unit(*this);
    }
 
 
    Unit::Unit(String* name)
                : name(name) { set_parent_in_children(); }
 
 
        Unit::Unit(std::shared_ptr<String> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Unit::Unit(const Unit& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Unit::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void Unit::set_name(std::shared_ptr<String>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void Unit::set_name(const std::shared_ptr<String>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// DoubleUnit member functions definition
    ///
 
      
 
      
      
 
      
 
    void DoubleUnit::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void DoubleUnit::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void DoubleUnit::accept(visitor::Visitor& v) {
        v.visit_double_unit(*this);
    }
 
    void DoubleUnit::accept(visitor::ConstVisitor& v) const {
        v.visit_double_unit(*this);
    }
 
 
    DoubleUnit::DoubleUnit(Double* value, Unit* unit)
                : value(value), unit(unit) { set_parent_in_children(); }
 
 
        DoubleUnit::DoubleUnit(std::shared_ptr<Double> value, std::shared_ptr<Unit> unit)
                : value(value), unit(unit) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    DoubleUnit::DoubleUnit(const DoubleUnit& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void DoubleUnit::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
 
    }
 
 
    
                       void DoubleUnit::set_value(std::shared_ptr<Double>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void DoubleUnit::set_value(const std::shared_ptr<Double>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
    
                       void DoubleUnit::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void DoubleUnit::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// LocalVar member functions definition
    ///
 
      
 
      std::string LocalVar::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void LocalVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void LocalVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void LocalVar::accept(visitor::Visitor& v) {
        v.visit_local_var(*this);
    }
 
    void LocalVar::accept(visitor::ConstVisitor& v) const {
        v.visit_local_var(*this);
    }
 
 
    LocalVar::LocalVar(Identifier* name)
                : name(name) { set_parent_in_children(); }
 
 
        LocalVar::LocalVar(std::shared_ptr<Identifier> name)
                : name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LocalVar::LocalVar(const LocalVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LocalVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void LocalVar::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void LocalVar::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Limits member functions definition
    ///
 
      
 
      
      
 
      
 
    void Limits::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        min->accept(v);
        (void)v;
        /// use -> for pointer member
        max->accept(v);
        (void)v;
    }
 
    void Limits::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        min->accept(v);
        (void)v;
        /// use -> for pointer member
        max->accept(v);
        (void)v;
    }
 
    void Limits::accept(visitor::Visitor& v) {
        v.visit_limits(*this);
    }
 
    void Limits::accept(visitor::ConstVisitor& v) const {
        v.visit_limits(*this);
    }
 
 
    Limits::Limits(Number* min, Number* max)
                : min(min), max(max) { set_parent_in_children(); }
 
 
        Limits::Limits(std::shared_ptr<Number> min, std::shared_ptr<Number> max)
                : min(min), max(max) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Limits::Limits(const Limits& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.min) {
                this->min.reset(obj.min->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.max) {
                this->max.reset(obj.max->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Limits::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (min) {
                min->set_parent(this);
            }
            /// optional member could be nullptr
            if (max) {
                max->set_parent(this);
            }
 
    }
 
 
    
                       void Limits::set_min(std::shared_ptr<Number>&& min) {
                           this->min = min;
                           // set parents
                           if (min) {
                               min->set_parent(this);
                           }
                       }
 
                       void Limits::set_min(const std::shared_ptr<Number>& min) {
                           this->min = min;
                           // set parents
                           if (min) {
                               min->set_parent(this);
                           }
                       }
                    
    
                       void Limits::set_max(std::shared_ptr<Number>&& max) {
                           this->max = max;
                           // set parents
                           if (max) {
                               max->set_parent(this);
                           }
                       }
 
                       void Limits::set_max(const std::shared_ptr<Number>& max) {
                           this->max = max;
                           // set parents
                           if (max) {
                               max->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// NumberRange member functions definition
    ///
 
      
 
      
      
 
      
 
    void NumberRange::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        min->accept(v);
        (void)v;
        /// use -> for pointer member
        max->accept(v);
        (void)v;
    }
 
    void NumberRange::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        min->accept(v);
        (void)v;
        /// use -> for pointer member
        max->accept(v);
        (void)v;
    }
 
    void NumberRange::accept(visitor::Visitor& v) {
        v.visit_number_range(*this);
    }
 
    void NumberRange::accept(visitor::ConstVisitor& v) const {
        v.visit_number_range(*this);
    }
 
 
    NumberRange::NumberRange(Number* min, Number* max)
                : min(min), max(max) { set_parent_in_children(); }
 
 
        NumberRange::NumberRange(std::shared_ptr<Number> min, std::shared_ptr<Number> max)
                : min(min), max(max) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    NumberRange::NumberRange(const NumberRange& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.min) {
                this->min.reset(obj.min->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.max) {
                this->max.reset(obj.max->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NumberRange::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (min) {
                min->set_parent(this);
            }
            /// optional member could be nullptr
            if (max) {
                max->set_parent(this);
            }
 
    }
 
 
    
                       void NumberRange::set_min(std::shared_ptr<Number>&& min) {
                           this->min = min;
                           // set parents
                           if (min) {
                               min->set_parent(this);
                           }
                       }
 
                       void NumberRange::set_min(const std::shared_ptr<Number>& min) {
                           this->min = min;
                           // set parents
                           if (min) {
                               min->set_parent(this);
                           }
                       }
                    
    
                       void NumberRange::set_max(std::shared_ptr<Number>&& max) {
                           this->max = max;
                           // set parents
                           if (max) {
                               max->set_parent(this);
                           }
                       }
 
                       void NumberRange::set_max(const std::shared_ptr<Number>& max) {
                           this->max = max;
                           // set parents
                           if (max) {
                               max->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ConstantVar member functions definition
    ///
 
      
 
      std::string ConstantVar::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void ConstantVar::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void ConstantVar::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
    }
 
    void ConstantVar::accept(visitor::Visitor& v) {
        v.visit_constant_var(*this);
    }
 
    void ConstantVar::accept(visitor::ConstVisitor& v) const {
        v.visit_constant_var(*this);
    }
 
 
    ConstantVar::ConstantVar(Name* name, Number* value, Unit* unit)
                : name(name), value(value), unit(unit) { set_parent_in_children(); }
 
 
        ConstantVar::ConstantVar(std::shared_ptr<Name> name, std::shared_ptr<Number> value, std::shared_ptr<Unit> unit)
                : name(name), value(value), unit(unit) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ConstantVar::ConstantVar(const ConstantVar& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ConstantVar::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
 
    }
 
 
    
                       void ConstantVar::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ConstantVar::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void ConstantVar::set_value(std::shared_ptr<Number>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void ConstantVar::set_value(const std::shared_ptr<Number>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
    
                       void ConstantVar::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void ConstantVar::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BinaryOperator member functions definition
    ///
 
      
 
      
 
    void BinaryOperator::visit_children(visitor::Visitor& v) {
    }
 
    void BinaryOperator::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void BinaryOperator::accept(visitor::Visitor& v) {
        v.visit_binary_operator(*this);
    }
 
    void BinaryOperator::accept(visitor::ConstVisitor& v) const {
        v.visit_binary_operator(*this);
    }
 
 
    BinaryOperator::BinaryOperator(BinaryOp value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    BinaryOperator::BinaryOperator(const BinaryOperator& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BinaryOperator::set_parent_in_children() {
 
 
    }
 
 
    
                       void BinaryOperator::set_value(BinaryOp value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// UnaryOperator member functions definition
    ///
 
      
 
      
 
    void UnaryOperator::visit_children(visitor::Visitor& v) {
    }
 
    void UnaryOperator::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void UnaryOperator::accept(visitor::Visitor& v) {
        v.visit_unary_operator(*this);
    }
 
    void UnaryOperator::accept(visitor::ConstVisitor& v) const {
        v.visit_unary_operator(*this);
    }
 
 
    UnaryOperator::UnaryOperator(UnaryOp value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    UnaryOperator::UnaryOperator(const UnaryOperator& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void UnaryOperator::set_parent_in_children() {
 
 
    }
 
 
    
                       void UnaryOperator::set_value(UnaryOp value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// ReactionOperator member functions definition
    ///
 
      
 
      
 
    void ReactionOperator::visit_children(visitor::Visitor& v) {
    }
 
    void ReactionOperator::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void ReactionOperator::accept(visitor::Visitor& v) {
        v.visit_reaction_operator(*this);
    }
 
    void ReactionOperator::accept(visitor::ConstVisitor& v) const {
        v.visit_reaction_operator(*this);
    }
 
 
    ReactionOperator::ReactionOperator(ReactionOp value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    ReactionOperator::ReactionOperator(const ReactionOperator& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ReactionOperator::set_parent_in_children() {
 
 
    }
 
 
    
                       void ReactionOperator::set_value(ReactionOp value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// ParenExpression member functions definition
    ///
 
      
 
      
 
    void ParenExpression::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void ParenExpression::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void ParenExpression::accept(visitor::Visitor& v) {
        v.visit_paren_expression(*this);
    }
 
    void ParenExpression::accept(visitor::ConstVisitor& v) const {
        v.visit_paren_expression(*this);
    }
 
 
    ParenExpression::ParenExpression(Expression* expression)
                : expression(expression) { set_parent_in_children(); }
 
 
        ParenExpression::ParenExpression(std::shared_ptr<Expression> expression)
                : expression(expression) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ParenExpression::ParenExpression(const ParenExpression& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ParenExpression::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
 
    }
 
 
    
                       void ParenExpression::set_expression(std::shared_ptr<Expression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void ParenExpression::set_expression(const std::shared_ptr<Expression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BinaryExpression member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
 
    void BinaryExpression::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        lhs->accept(v);
        (void)v;
        /// use . for object member
        op.accept(v);
        (void)v;
        /// use -> for pointer member
        rhs->accept(v);
        (void)v;
    }
 
    void BinaryExpression::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        lhs->accept(v);
        (void)v;
        /// use . for object member
        op.accept(v);
        (void)v;
        /// use -> for pointer member
        rhs->accept(v);
        (void)v;
    }
 
    void BinaryExpression::accept(visitor::Visitor& v) {
        v.visit_binary_expression(*this);
    }
 
    void BinaryExpression::accept(visitor::ConstVisitor& v) const {
        v.visit_binary_expression(*this);
    }
 
 
    BinaryExpression::BinaryExpression(Expression* lhs, const BinaryOperator& op, Expression* rhs)
                : lhs(lhs), op(op), rhs(rhs) { set_parent_in_children(); }
 
 
        BinaryExpression::BinaryExpression(std::shared_ptr<Expression> lhs, const BinaryOperator& op, std::shared_ptr<Expression> rhs)
                : lhs(lhs), op(op), rhs(rhs) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    BinaryExpression::BinaryExpression(const BinaryExpression& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.lhs) {
                this->lhs.reset(obj.lhs->clone());
            }
            /// object member can be just copied by value
            this->op = obj.op;
            /// pointer member must be reseted with the new copy
            if (obj.rhs) {
                this->rhs.reset(obj.rhs->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BinaryExpression::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (lhs) {
                lhs->set_parent(this);
            }
                op.set_parent(this);
            /// optional member could be nullptr
            if (rhs) {
                rhs->set_parent(this);
            }
 
    }
 
 
    
                       void BinaryExpression::set_lhs(std::shared_ptr<Expression>&& lhs) {
                           this->lhs = lhs;
                           // set parents
                           if (lhs) {
                               lhs->set_parent(this);
                           }
                       }
 
                       void BinaryExpression::set_lhs(const std::shared_ptr<Expression>& lhs) {
                           this->lhs = lhs;
                           // set parents
                           if (lhs) {
                               lhs->set_parent(this);
                           }
                       }
                    
    
                       void BinaryExpression::set_op(BinaryOperator&& op) {
                           this->op = op;
                       }
 
                       void BinaryExpression::set_op(const BinaryOperator& op) {
                           this->op = op;
                       }
                    
    
                       void BinaryExpression::set_rhs(std::shared_ptr<Expression>&& rhs) {
                           this->rhs = rhs;
                           // set parents
                           if (rhs) {
                               rhs->set_parent(this);
                           }
                       }
 
                       void BinaryExpression::set_rhs(const std::shared_ptr<Expression>& rhs) {
                           this->rhs = rhs;
                           // set parents
                           if (rhs) {
                               rhs->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// DiffEqExpression member functions definition
    ///
 
      
 
      
 
    void DiffEqExpression::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void DiffEqExpression::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void DiffEqExpression::accept(visitor::Visitor& v) {
        v.visit_diff_eq_expression(*this);
    }
 
    void DiffEqExpression::accept(visitor::ConstVisitor& v) const {
        v.visit_diff_eq_expression(*this);
    }
 
 
    DiffEqExpression::DiffEqExpression(BinaryExpression* expression)
                : expression(expression) { set_parent_in_children(); }
 
 
        DiffEqExpression::DiffEqExpression(std::shared_ptr<BinaryExpression> expression)
                : expression(expression) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    DiffEqExpression::DiffEqExpression(const DiffEqExpression& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void DiffEqExpression::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
 
    }
 
 
    
                       void DiffEqExpression::set_expression(std::shared_ptr<BinaryExpression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void DiffEqExpression::set_expression(const std::shared_ptr<BinaryExpression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// UnaryExpression member functions definition
    ///
 
      
 
      
      
 
      
 
    void UnaryExpression::visit_children(visitor::Visitor& v) {
        /// use . for object member
        op.accept(v);
        (void)v;
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void UnaryExpression::visit_children(visitor::ConstVisitor& v) const {
        /// use . for object member
        op.accept(v);
        (void)v;
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void UnaryExpression::accept(visitor::Visitor& v) {
        v.visit_unary_expression(*this);
    }
 
    void UnaryExpression::accept(visitor::ConstVisitor& v) const {
        v.visit_unary_expression(*this);
    }
 
 
    UnaryExpression::UnaryExpression(const UnaryOperator& op, Expression* expression)
                : op(op), expression(expression) { set_parent_in_children(); }
 
 
        UnaryExpression::UnaryExpression(const UnaryOperator& op, std::shared_ptr<Expression> expression)
                : op(op), expression(expression) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    UnaryExpression::UnaryExpression(const UnaryExpression& obj) {
            /// object member can be just copied by value
            this->op = obj.op;
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void UnaryExpression::set_parent_in_children() {
 
                op.set_parent(this);
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
 
    }
 
 
    
                       void UnaryExpression::set_op(UnaryOperator&& op) {
                           this->op = op;
                       }
 
                       void UnaryExpression::set_op(const UnaryOperator& op) {
                           this->op = op;
                       }
                    
    
                       void UnaryExpression::set_expression(std::shared_ptr<Expression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void UnaryExpression::set_expression(const std::shared_ptr<Expression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// NonLinEquation member functions definition
    ///
 
      
 
      
      
 
      
 
    void NonLinEquation::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        lhs->accept(v);
        (void)v;
        /// use -> for pointer member
        rhs->accept(v);
        (void)v;
    }
 
    void NonLinEquation::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        lhs->accept(v);
        (void)v;
        /// use -> for pointer member
        rhs->accept(v);
        (void)v;
    }
 
    void NonLinEquation::accept(visitor::Visitor& v) {
        v.visit_non_lin_equation(*this);
    }
 
    void NonLinEquation::accept(visitor::ConstVisitor& v) const {
        v.visit_non_lin_equation(*this);
    }
 
 
    NonLinEquation::NonLinEquation(Expression* lhs, Expression* rhs)
                : lhs(lhs), rhs(rhs) { set_parent_in_children(); }
 
 
        NonLinEquation::NonLinEquation(std::shared_ptr<Expression> lhs, std::shared_ptr<Expression> rhs)
                : lhs(lhs), rhs(rhs) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    NonLinEquation::NonLinEquation(const NonLinEquation& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.lhs) {
                this->lhs.reset(obj.lhs->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.rhs) {
                this->rhs.reset(obj.rhs->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NonLinEquation::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (lhs) {
                lhs->set_parent(this);
            }
            /// optional member could be nullptr
            if (rhs) {
                rhs->set_parent(this);
            }
 
    }
 
 
    
                       void NonLinEquation::set_lhs(std::shared_ptr<Expression>&& lhs) {
                           this->lhs = lhs;
                           // set parents
                           if (lhs) {
                               lhs->set_parent(this);
                           }
                       }
 
                       void NonLinEquation::set_lhs(const std::shared_ptr<Expression>& lhs) {
                           this->lhs = lhs;
                           // set parents
                           if (lhs) {
                               lhs->set_parent(this);
                           }
                       }
                    
    
                       void NonLinEquation::set_rhs(std::shared_ptr<Expression>&& rhs) {
                           this->rhs = rhs;
                           // set parents
                           if (rhs) {
                               rhs->set_parent(this);
                           }
                       }
 
                       void NonLinEquation::set_rhs(const std::shared_ptr<Expression>& rhs) {
                           this->rhs = rhs;
                           // set parents
                           if (rhs) {
                               rhs->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// LinEquation member functions definition
    ///
 
      
 
      
      
 
      
 
    void LinEquation::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        lhs->accept(v);
        (void)v;
        /// use -> for pointer member
        rhs->accept(v);
        (void)v;
    }
 
    void LinEquation::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        lhs->accept(v);
        (void)v;
        /// use -> for pointer member
        rhs->accept(v);
        (void)v;
    }
 
    void LinEquation::accept(visitor::Visitor& v) {
        v.visit_lin_equation(*this);
    }
 
    void LinEquation::accept(visitor::ConstVisitor& v) const {
        v.visit_lin_equation(*this);
    }
 
 
    LinEquation::LinEquation(Expression* lhs, Expression* rhs)
                : lhs(lhs), rhs(rhs) { set_parent_in_children(); }
 
 
        LinEquation::LinEquation(std::shared_ptr<Expression> lhs, std::shared_ptr<Expression> rhs)
                : lhs(lhs), rhs(rhs) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LinEquation::LinEquation(const LinEquation& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.lhs) {
                this->lhs.reset(obj.lhs->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.rhs) {
                this->rhs.reset(obj.rhs->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LinEquation::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (lhs) {
                lhs->set_parent(this);
            }
            /// optional member could be nullptr
            if (rhs) {
                rhs->set_parent(this);
            }
 
    }
 
 
    
                       void LinEquation::set_lhs(std::shared_ptr<Expression>&& lhs) {
                           this->lhs = lhs;
                           // set parents
                           if (lhs) {
                               lhs->set_parent(this);
                           }
                       }
 
                       void LinEquation::set_lhs(const std::shared_ptr<Expression>& lhs) {
                           this->lhs = lhs;
                           // set parents
                           if (lhs) {
                               lhs->set_parent(this);
                           }
                       }
                    
    
                       void LinEquation::set_rhs(std::shared_ptr<Expression>&& rhs) {
                           this->rhs = rhs;
                           // set parents
                           if (rhs) {
                               rhs->set_parent(this);
                           }
                       }
 
                       void LinEquation::set_rhs(const std::shared_ptr<Expression>& rhs) {
                           this->rhs = rhs;
                           // set parents
                           if (rhs) {
                               rhs->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// FunctionCall member functions definition
    ///
 
      
 
      std::string FunctionCall::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
 
    void FunctionCall::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->arguments) {
            item->accept(v);
        }
        (void)v;
    }
 
    void FunctionCall::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->arguments) {
            item->accept(v);
        }
        (void)v;
    }
 
    void FunctionCall::accept(visitor::Visitor& v) {
        v.visit_function_call(*this);
    }
 
    void FunctionCall::accept(visitor::ConstVisitor& v) const {
        v.visit_function_call(*this);
    }
 
 
    FunctionCall::FunctionCall(Name* name, const ExpressionVector& arguments)
                : name(name), arguments(arguments) { set_parent_in_children(); }
 
 
        FunctionCall::FunctionCall(std::shared_ptr<Name> name, const ExpressionVector& arguments)
                : name(name), arguments(arguments) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    FunctionCall::FunctionCall(const FunctionCall& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.arguments) {
                this->arguments.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void FunctionCall::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : arguments) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void FunctionCall::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void FunctionCall::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void FunctionCall::set_arguments(ExpressionVector&& arguments) {
                           this->arguments = arguments;
                           // set parents
                           for (auto& ii : arguments) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void FunctionCall::set_arguments(const ExpressionVector& arguments) {
                           this->arguments = arguments;
                           // set parents
                           for (auto& ii : arguments) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// Watch member functions definition
    ///
 
      
 
      
      
 
      
 
    void Watch::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Watch::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Watch::accept(visitor::Visitor& v) {
        v.visit_watch(*this);
    }
 
    void Watch::accept(visitor::ConstVisitor& v) const {
        v.visit_watch(*this);
    }
 
 
    Watch::Watch(Expression* expression, Expression* value)
                : expression(expression), value(value) { set_parent_in_children(); }
 
 
        Watch::Watch(std::shared_ptr<Expression> expression, std::shared_ptr<Expression> value)
                : expression(expression), value(value) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Watch::Watch(const Watch& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Watch::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
 
    }
 
 
    
                       void Watch::set_expression(std::shared_ptr<Expression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void Watch::set_expression(const std::shared_ptr<Expression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
    
                       void Watch::set_value(std::shared_ptr<Expression>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void Watch::set_value(const std::shared_ptr<Expression>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BABlockType member functions definition
    ///
 
      
 
      
 
    void BABlockType::visit_children(visitor::Visitor& v) {
    }
 
    void BABlockType::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void BABlockType::accept(visitor::Visitor& v) {
        v.visit_ba_block_type(*this);
    }
 
    void BABlockType::accept(visitor::ConstVisitor& v) const {
        v.visit_ba_block_type(*this);
    }
 
 
    BABlockType::BABlockType(BAType value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    BABlockType::BABlockType(const BABlockType& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BABlockType::set_parent_in_children() {
 
 
    }
 
 
    
                       void BABlockType::set_value(BAType value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// UnitDef member functions definition
    ///
 
      
 
      std::string UnitDef::get_node_name() const {
                             return unit1->get_node_name();
                         }
      
 
      
 
    void UnitDef::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        unit1->accept(v);
        (void)v;
        /// use -> for pointer member
        unit2->accept(v);
        (void)v;
    }
 
    void UnitDef::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        unit1->accept(v);
        (void)v;
        /// use -> for pointer member
        unit2->accept(v);
        (void)v;
    }
 
    void UnitDef::accept(visitor::Visitor& v) {
        v.visit_unit_def(*this);
    }
 
    void UnitDef::accept(visitor::ConstVisitor& v) const {
        v.visit_unit_def(*this);
    }
 
 
    UnitDef::UnitDef(Unit* unit1, Unit* unit2)
                : unit1(unit1), unit2(unit2) { set_parent_in_children(); }
 
 
        UnitDef::UnitDef(std::shared_ptr<Unit> unit1, std::shared_ptr<Unit> unit2)
                : unit1(unit1), unit2(unit2) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    UnitDef::UnitDef(const UnitDef& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.unit1) {
                this->unit1.reset(obj.unit1->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit2) {
                this->unit2.reset(obj.unit2->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void UnitDef::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (unit1) {
                unit1->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit2) {
                unit2->set_parent(this);
            }
 
    }
 
 
    
                       void UnitDef::set_unit1(std::shared_ptr<Unit>&& unit1) {
                           this->unit1 = unit1;
                           // set parents
                           if (unit1) {
                               unit1->set_parent(this);
                           }
                       }
 
                       void UnitDef::set_unit1(const std::shared_ptr<Unit>& unit1) {
                           this->unit1 = unit1;
                           // set parents
                           if (unit1) {
                               unit1->set_parent(this);
                           }
                       }
                    
    
                       void UnitDef::set_unit2(std::shared_ptr<Unit>&& unit2) {
                           this->unit2 = unit2;
                           // set parents
                           if (unit2) {
                               unit2->set_parent(this);
                           }
                       }
 
                       void UnitDef::set_unit2(const std::shared_ptr<Unit>& unit2) {
                           this->unit2 = unit2;
                           // set parents
                           if (unit2) {
                               unit2->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// FactorDef member functions definition
    ///
 
      
 
      std::string FactorDef::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
      
 
      
 
    void FactorDef::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->value) {
            this->value->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        unit1->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->gt) {
            this->gt->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit2) {
            this->unit2->accept(v);
        }
        (void)v;
    }
 
    void FactorDef::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->value) {
            this->value->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        unit1->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->gt) {
            this->gt->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit2) {
            this->unit2->accept(v);
        }
        (void)v;
    }
 
    void FactorDef::accept(visitor::Visitor& v) {
        v.visit_factor_def(*this);
    }
 
    void FactorDef::accept(visitor::ConstVisitor& v) const {
        v.visit_factor_def(*this);
    }
 
 
    FactorDef::FactorDef(Name* name, Double* value, Unit* unit1, Boolean* gt, Unit* unit2)
                : name(name), value(value), unit1(unit1), gt(gt), unit2(unit2) { set_parent_in_children(); }
 
 
        FactorDef::FactorDef(std::shared_ptr<Name> name, std::shared_ptr<Double> value, std::shared_ptr<Unit> unit1, std::shared_ptr<Boolean> gt, std::shared_ptr<Unit> unit2)
                : name(name), value(value), unit1(unit1), gt(gt), unit2(unit2) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    FactorDef::FactorDef(const FactorDef& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit1) {
                this->unit1.reset(obj.unit1->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.gt) {
                this->gt.reset(obj.gt->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit2) {
                this->unit2.reset(obj.unit2->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void FactorDef::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit1) {
                unit1->set_parent(this);
            }
            /// optional member could be nullptr
            if (gt) {
                gt->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit2) {
                unit2->set_parent(this);
            }
 
    }
 
 
    
                       void FactorDef::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void FactorDef::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void FactorDef::set_value(std::shared_ptr<Double>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void FactorDef::set_value(const std::shared_ptr<Double>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
    
                       void FactorDef::set_unit1(std::shared_ptr<Unit>&& unit1) {
                           this->unit1 = unit1;
                           // set parents
                           if (unit1) {
                               unit1->set_parent(this);
                           }
                       }
 
                       void FactorDef::set_unit1(const std::shared_ptr<Unit>& unit1) {
                           this->unit1 = unit1;
                           // set parents
                           if (unit1) {
                               unit1->set_parent(this);
                           }
                       }
                    
    
                       void FactorDef::set_gt(std::shared_ptr<Boolean>&& gt) {
                           this->gt = gt;
                           // set parents
                           if (gt) {
                               gt->set_parent(this);
                           }
                       }
 
                       void FactorDef::set_gt(const std::shared_ptr<Boolean>& gt) {
                           this->gt = gt;
                           // set parents
                           if (gt) {
                               gt->set_parent(this);
                           }
                       }
                    
    
                       void FactorDef::set_unit2(std::shared_ptr<Unit>&& unit2) {
                           this->unit2 = unit2;
                           // set parents
                           if (unit2) {
                               unit2->set_parent(this);
                           }
                       }
 
                       void FactorDef::set_unit2(const std::shared_ptr<Unit>& unit2) {
                           this->unit2 = unit2;
                           // set parents
                           if (unit2) {
                               unit2->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Valence member functions definition
    ///
 
      
 
      
      
 
      
 
    void Valence::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        type->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Valence::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        type->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Valence::accept(visitor::Visitor& v) {
        v.visit_valence(*this);
    }
 
    void Valence::accept(visitor::ConstVisitor& v) const {
        v.visit_valence(*this);
    }
 
 
    Valence::Valence(Name* type, Double* value)
                : type(type), value(value) { set_parent_in_children(); }
 
 
        Valence::Valence(std::shared_ptr<Name> type, std::shared_ptr<Double> value)
                : type(type), value(value) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Valence::Valence(const Valence& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.type) {
                this->type.reset(obj.type->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Valence::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (type) {
                type->set_parent(this);
            }
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
 
    }
 
 
    
                       void Valence::set_type(std::shared_ptr<Name>&& type) {
                           this->type = type;
                           // set parents
                           if (type) {
                               type->set_parent(this);
                           }
                       }
 
                       void Valence::set_type(const std::shared_ptr<Name>& type) {
                           this->type = type;
                           // set parents
                           if (type) {
                               type->set_parent(this);
                           }
                       }
                    
    
                       void Valence::set_value(std::shared_ptr<Double>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void Valence::set_value(const std::shared_ptr<Double>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// UnitState member functions definition
    ///
 
      
 
      
 
    void UnitState::visit_children(visitor::Visitor& v) {
    }
 
    void UnitState::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void UnitState::accept(visitor::Visitor& v) {
        v.visit_unit_state(*this);
    }
 
    void UnitState::accept(visitor::ConstVisitor& v) const {
        v.visit_unit_state(*this);
    }
 
 
    UnitState::UnitState(UnitStateType value)
                : value(value) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    UnitState::UnitState(const UnitState& obj) {
            /// object member can be just copied by value
            this->value = obj.value;
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void UnitState::set_parent_in_children() {
 
 
    }
 
 
    
                       void UnitState::set_value(UnitStateType value) {
                           // why don't we use a coding convention instead of this workaround for
                           // variable shadowing?
                           this->value = value;
                       }
                    
 
 
    ///
    /// LocalListStatement member functions definition
    ///
 
      
/**
 * \brief Add member to variables by raw pointer
 */
void LocalListStatement::emplace_back_local_var(LocalVar *n) {
   variables.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to variables by shared_ptr
 */
void LocalListStatement::emplace_back_local_var(std::shared_ptr<LocalVar> n) {
   variables.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to variables
 */
LocalVarVector::const_iterator LocalListStatement::erase_local_var(LocalVarVector::const_iterator first) {
   return variables.erase(first);
}
/**
 * \brief Erase members to variables
 */
LocalVarVector::const_iterator LocalListStatement::erase_local_var(LocalVarVector::const_iterator first, LocalVarVector::const_iterator last) {
   return variables.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to variables
 *
 * loosely following the cpp reference of remove_if
 */
size_t LocalListStatement::erase_local_var(std::unordered_set<LocalVar*>& to_be_erased) {
   auto first = variables.begin();
   auto last = variables.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_local_var(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_local_var(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to variables
 */
LocalVarVector::const_iterator LocalListStatement::insert_local_var(LocalVarVector::const_iterator position, const std::shared_ptr<LocalVar>& n) {
    n->set_parent(this); 
   return variables.insert(position, n);
}
 
/**
 * \brief Reset member to variables
 */
void LocalListStatement::reset_local_var(LocalVarVector::const_iterator position, LocalVar* n) {
    //set parents
    n->set_parent(this); 
 
   variables[position - variables.begin()].reset(n);
}
 
/**
 * \brief Reset member to variables
 */
void LocalListStatement::reset_local_var(LocalVarVector::const_iterator position, std::shared_ptr<LocalVar> n) {
    //set parents
    n->set_parent(this); 
 
   variables[position - variables.begin()] = n;
}
 
 
      
 
    void LocalListStatement::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void LocalListStatement::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void LocalListStatement::accept(visitor::Visitor& v) {
        v.visit_local_list_statement(*this);
    }
 
    void LocalListStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_local_list_statement(*this);
    }
 
 
    LocalListStatement::LocalListStatement(const LocalVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    LocalListStatement::LocalListStatement(const LocalListStatement& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LocalListStatement::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void LocalListStatement::set_variables(LocalVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void LocalListStatement::set_variables(const LocalVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// Model member functions definition
    ///
 
      
 
      
 
    void Model::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        title->accept(v);
        (void)v;
    }
 
    void Model::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        title->accept(v);
        (void)v;
    }
 
    void Model::accept(visitor::Visitor& v) {
        v.visit_model(*this);
    }
 
    void Model::accept(visitor::ConstVisitor& v) const {
        v.visit_model(*this);
    }
 
 
    Model::Model(String* title)
                : title(title) { set_parent_in_children(); }
 
 
        Model::Model(std::shared_ptr<String> title)
                : title(title) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Model::Model(const Model& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.title) {
                this->title.reset(obj.title->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Model::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (title) {
                title->set_parent(this);
            }
 
    }
 
 
    
                       void Model::set_title(std::shared_ptr<String>&& title) {
                           this->title = title;
                           // set parents
                           if (title) {
                               title->set_parent(this);
                           }
                       }
 
                       void Model::set_title(const std::shared_ptr<String>& title) {
                           this->title = title;
                           // set parents
                           if (title) {
                               title->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Define member functions definition
    ///
 
      
 
      std::string Define::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
 
    void Define::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Define::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void Define::accept(visitor::Visitor& v) {
        v.visit_define(*this);
    }
 
    void Define::accept(visitor::ConstVisitor& v) const {
        v.visit_define(*this);
    }
 
 
    Define::Define(Name* name, Integer* value)
                : name(name), value(value) { set_parent_in_children(); }
 
 
        Define::Define(std::shared_ptr<Name> name, std::shared_ptr<Integer> value)
                : name(name), value(value) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Define::Define(const Define& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Define::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
 
    }
 
 
    
                       void Define::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void Define::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void Define::set_value(std::shared_ptr<Integer>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void Define::set_value(const std::shared_ptr<Integer>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Include member functions definition
    ///
 
      
 
      
      
 
      
 
    void Include::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        filename->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->blocks) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Include::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        filename->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->blocks) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Include::accept(visitor::Visitor& v) {
        v.visit_include(*this);
    }
 
    void Include::accept(visitor::ConstVisitor& v) const {
        v.visit_include(*this);
    }
 
 
    Include::Include(String* filename, const NodeVector& blocks)
                : filename(filename), blocks(blocks) { set_parent_in_children(); }
 
 
        Include::Include(std::shared_ptr<String> filename, const NodeVector& blocks)
                : filename(filename), blocks(blocks) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Include::Include(const Include& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.filename) {
                this->filename.reset(obj.filename->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.blocks) {
                this->blocks.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Include::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (filename) {
                filename->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : blocks) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Include::set_filename(std::shared_ptr<String>&& filename) {
                           this->filename = filename;
                           // set parents
                           if (filename) {
                               filename->set_parent(this);
                           }
                       }
 
                       void Include::set_filename(const std::shared_ptr<String>& filename) {
                           this->filename = filename;
                           // set parents
                           if (filename) {
                               filename->set_parent(this);
                           }
                       }
                    
    
                       void Include::set_blocks(NodeVector&& blocks) {
                           this->blocks = blocks;
                           // set parents
                           for (auto& ii : blocks) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Include::set_blocks(const NodeVector& blocks) {
                           this->blocks = blocks;
                           // set parents
                           for (auto& ii : blocks) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// ParamAssign member functions definition
    ///
 
      
 
      std::string ParamAssign::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
 
    void ParamAssign::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->value) {
            this->value->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->limit) {
            this->limit->accept(v);
        }
        (void)v;
    }
 
    void ParamAssign::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->value) {
            this->value->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->limit) {
            this->limit->accept(v);
        }
        (void)v;
    }
 
    void ParamAssign::accept(visitor::Visitor& v) {
        v.visit_param_assign(*this);
    }
 
    void ParamAssign::accept(visitor::ConstVisitor& v) const {
        v.visit_param_assign(*this);
    }
 
 
    ParamAssign::ParamAssign(Identifier* name, Number* value, Unit* unit, Limits* limit)
                : name(name), value(value), unit(unit), limit(limit) { set_parent_in_children(); }
 
 
        ParamAssign::ParamAssign(std::shared_ptr<Identifier> name, std::shared_ptr<Number> value, std::shared_ptr<Unit> unit, std::shared_ptr<Limits> limit)
                : name(name), value(value), unit(unit), limit(limit) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ParamAssign::ParamAssign(const ParamAssign& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.limit) {
                this->limit.reset(obj.limit->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ParamAssign::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
            /// optional member could be nullptr
            if (limit) {
                limit->set_parent(this);
            }
 
    }
 
 
    
                       void ParamAssign::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void ParamAssign::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void ParamAssign::set_value(std::shared_ptr<Number>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void ParamAssign::set_value(const std::shared_ptr<Number>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
    
                       void ParamAssign::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void ParamAssign::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
    
                       void ParamAssign::set_limit(std::shared_ptr<Limits>&& limit) {
                           this->limit = limit;
                           // set parents
                           if (limit) {
                               limit->set_parent(this);
                           }
                       }
 
                       void ParamAssign::set_limit(const std::shared_ptr<Limits>& limit) {
                           this->limit = limit;
                           // set parents
                           if (limit) {
                               limit->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// AssignedDefinition member functions definition
    ///
 
      
 
      std::string AssignedDefinition::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
 
    void AssignedDefinition::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->length) {
            this->length->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->from) {
            this->from->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->to) {
            this->to->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->start) {
            this->start->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->abstol) {
            this->abstol->accept(v);
        }
        (void)v;
    }
 
    void AssignedDefinition::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->length) {
            this->length->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->from) {
            this->from->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->to) {
            this->to->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->start) {
            this->start->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->unit) {
            this->unit->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->abstol) {
            this->abstol->accept(v);
        }
        (void)v;
    }
 
    void AssignedDefinition::accept(visitor::Visitor& v) {
        v.visit_assigned_definition(*this);
    }
 
    void AssignedDefinition::accept(visitor::ConstVisitor& v) const {
        v.visit_assigned_definition(*this);
    }
 
 
    AssignedDefinition::AssignedDefinition(Identifier* name, Integer* length, Number* from, Number* to, Number* start, Unit* unit, Double* abstol)
                : name(name), length(length), from(from), to(to), start(start), unit(unit), abstol(abstol) { set_parent_in_children(); }
 
 
        AssignedDefinition::AssignedDefinition(std::shared_ptr<Identifier> name, std::shared_ptr<Integer> length, std::shared_ptr<Number> from, std::shared_ptr<Number> to, std::shared_ptr<Number> start, std::shared_ptr<Unit> unit, std::shared_ptr<Double> abstol)
                : name(name), length(length), from(from), to(to), start(start), unit(unit), abstol(abstol) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    AssignedDefinition::AssignedDefinition(const AssignedDefinition& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.length) {
                this->length.reset(obj.length->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.from) {
                this->from.reset(obj.from->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.to) {
                this->to.reset(obj.to->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.start) {
                this->start.reset(obj.start->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.unit) {
                this->unit.reset(obj.unit->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.abstol) {
                this->abstol.reset(obj.abstol->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void AssignedDefinition::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (length) {
                length->set_parent(this);
            }
            /// optional member could be nullptr
            if (from) {
                from->set_parent(this);
            }
            /// optional member could be nullptr
            if (to) {
                to->set_parent(this);
            }
            /// optional member could be nullptr
            if (start) {
                start->set_parent(this);
            }
            /// optional member could be nullptr
            if (unit) {
                unit->set_parent(this);
            }
            /// optional member could be nullptr
            if (abstol) {
                abstol->set_parent(this);
            }
 
    }
 
 
    
                       void AssignedDefinition::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void AssignedDefinition::set_length(std::shared_ptr<Integer>&& length) {
                           this->length = length;
                           // set parents
                           if (length) {
                               length->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_length(const std::shared_ptr<Integer>& length) {
                           this->length = length;
                           // set parents
                           if (length) {
                               length->set_parent(this);
                           }
                       }
                    
    
                       void AssignedDefinition::set_from(std::shared_ptr<Number>&& from) {
                           this->from = from;
                           // set parents
                           if (from) {
                               from->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_from(const std::shared_ptr<Number>& from) {
                           this->from = from;
                           // set parents
                           if (from) {
                               from->set_parent(this);
                           }
                       }
                    
    
                       void AssignedDefinition::set_to(std::shared_ptr<Number>&& to) {
                           this->to = to;
                           // set parents
                           if (to) {
                               to->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_to(const std::shared_ptr<Number>& to) {
                           this->to = to;
                           // set parents
                           if (to) {
                               to->set_parent(this);
                           }
                       }
                    
    
                       void AssignedDefinition::set_start(std::shared_ptr<Number>&& start) {
                           this->start = start;
                           // set parents
                           if (start) {
                               start->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_start(const std::shared_ptr<Number>& start) {
                           this->start = start;
                           // set parents
                           if (start) {
                               start->set_parent(this);
                           }
                       }
                    
    
                       void AssignedDefinition::set_unit(std::shared_ptr<Unit>&& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_unit(const std::shared_ptr<Unit>& unit) {
                           this->unit = unit;
                           // set parents
                           if (unit) {
                               unit->set_parent(this);
                           }
                       }
                    
    
                       void AssignedDefinition::set_abstol(std::shared_ptr<Double>&& abstol) {
                           this->abstol = abstol;
                           // set parents
                           if (abstol) {
                               abstol->set_parent(this);
                           }
                       }
 
                       void AssignedDefinition::set_abstol(const std::shared_ptr<Double>& abstol) {
                           this->abstol = abstol;
                           // set parents
                           if (abstol) {
                               abstol->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ConductanceHint member functions definition
    ///
 
      
 
      
      
 
      
 
    void ConductanceHint::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        conductance->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->ion) {
            this->ion->accept(v);
        }
        (void)v;
    }
 
    void ConductanceHint::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        conductance->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->ion) {
            this->ion->accept(v);
        }
        (void)v;
    }
 
    void ConductanceHint::accept(visitor::Visitor& v) {
        v.visit_conductance_hint(*this);
    }
 
    void ConductanceHint::accept(visitor::ConstVisitor& v) const {
        v.visit_conductance_hint(*this);
    }
 
 
    ConductanceHint::ConductanceHint(Name* conductance, Name* ion)
                : conductance(conductance), ion(ion) { set_parent_in_children(); }
 
 
        ConductanceHint::ConductanceHint(std::shared_ptr<Name> conductance, std::shared_ptr<Name> ion)
                : conductance(conductance), ion(ion) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ConductanceHint::ConductanceHint(const ConductanceHint& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.conductance) {
                this->conductance.reset(obj.conductance->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.ion) {
                this->ion.reset(obj.ion->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ConductanceHint::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (conductance) {
                conductance->set_parent(this);
            }
            /// optional member could be nullptr
            if (ion) {
                ion->set_parent(this);
            }
 
    }
 
 
    
                       void ConductanceHint::set_conductance(std::shared_ptr<Name>&& conductance) {
                           this->conductance = conductance;
                           // set parents
                           if (conductance) {
                               conductance->set_parent(this);
                           }
                       }
 
                       void ConductanceHint::set_conductance(const std::shared_ptr<Name>& conductance) {
                           this->conductance = conductance;
                           // set parents
                           if (conductance) {
                               conductance->set_parent(this);
                           }
                       }
                    
    
                       void ConductanceHint::set_ion(std::shared_ptr<Name>&& ion) {
                           this->ion = ion;
                           // set parents
                           if (ion) {
                               ion->set_parent(this);
                           }
                       }
 
                       void ConductanceHint::set_ion(const std::shared_ptr<Name>& ion) {
                           this->ion = ion;
                           // set parents
                           if (ion) {
                               ion->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ExpressionStatement member functions definition
    ///
 
      
 
      
 
    void ExpressionStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void ExpressionStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void ExpressionStatement::accept(visitor::Visitor& v) {
        v.visit_expression_statement(*this);
    }
 
    void ExpressionStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_expression_statement(*this);
    }
 
 
    ExpressionStatement::ExpressionStatement(Expression* expression)
                : expression(expression) { set_parent_in_children(); }
 
 
        ExpressionStatement::ExpressionStatement(std::shared_ptr<Expression> expression)
                : expression(expression) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ExpressionStatement::ExpressionStatement(const ExpressionStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ExpressionStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
 
    }
 
 
    
                       void ExpressionStatement::set_expression(std::shared_ptr<Expression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void ExpressionStatement::set_expression(const std::shared_ptr<Expression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ProtectStatement member functions definition
    ///
 
      
 
      
 
    void ProtectStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void ProtectStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void ProtectStatement::accept(visitor::Visitor& v) {
        v.visit_protect_statement(*this);
    }
 
    void ProtectStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_protect_statement(*this);
    }
 
 
    ProtectStatement::ProtectStatement(Expression* expression)
                : expression(expression) { set_parent_in_children(); }
 
 
        ProtectStatement::ProtectStatement(std::shared_ptr<Expression> expression)
                : expression(expression) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ProtectStatement::ProtectStatement(const ProtectStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ProtectStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
 
    }
 
 
    
                       void ProtectStatement::set_expression(std::shared_ptr<Expression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void ProtectStatement::set_expression(const std::shared_ptr<Expression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// FromStatement member functions definition
    ///
 
      
 
      std::string FromStatement::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
      
 
      
 
    void FromStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        from->accept(v);
        (void)v;
        /// use -> for pointer member
        to->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->increment) {
            this->increment->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void FromStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        from->accept(v);
        (void)v;
        /// use -> for pointer member
        to->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->increment) {
            this->increment->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void FromStatement::accept(visitor::Visitor& v) {
        v.visit_from_statement(*this);
    }
 
    void FromStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_from_statement(*this);
    }
 
 
    FromStatement::FromStatement(Name* name, Expression* from, Expression* to, Expression* increment, StatementBlock* statement_block)
                : name(name), from(from), to(to), increment(increment), statement_block(statement_block) { set_parent_in_children(); }
 
 
        FromStatement::FromStatement(std::shared_ptr<Name> name, std::shared_ptr<Expression> from, std::shared_ptr<Expression> to, std::shared_ptr<Expression> increment, std::shared_ptr<StatementBlock> statement_block)
                : name(name), from(from), to(to), increment(increment), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    FromStatement::FromStatement(const FromStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.from) {
                this->from.reset(obj.from->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.to) {
                this->to.reset(obj.to->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.increment) {
                this->increment.reset(obj.increment->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void FromStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (from) {
                from->set_parent(this);
            }
            /// optional member could be nullptr
            if (to) {
                to->set_parent(this);
            }
            /// optional member could be nullptr
            if (increment) {
                increment->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void FromStatement::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void FromStatement::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void FromStatement::set_from(std::shared_ptr<Expression>&& from) {
                           this->from = from;
                           // set parents
                           if (from) {
                               from->set_parent(this);
                           }
                       }
 
                       void FromStatement::set_from(const std::shared_ptr<Expression>& from) {
                           this->from = from;
                           // set parents
                           if (from) {
                               from->set_parent(this);
                           }
                       }
                    
    
                       void FromStatement::set_to(std::shared_ptr<Expression>&& to) {
                           this->to = to;
                           // set parents
                           if (to) {
                               to->set_parent(this);
                           }
                       }
 
                       void FromStatement::set_to(const std::shared_ptr<Expression>& to) {
                           this->to = to;
                           // set parents
                           if (to) {
                               to->set_parent(this);
                           }
                       }
                    
    
                       void FromStatement::set_increment(std::shared_ptr<Expression>&& increment) {
                           this->increment = increment;
                           // set parents
                           if (increment) {
                               increment->set_parent(this);
                           }
                       }
 
                       void FromStatement::set_increment(const std::shared_ptr<Expression>& increment) {
                           this->increment = increment;
                           // set parents
                           if (increment) {
                               increment->set_parent(this);
                           }
                       }
                    
    
                       void FromStatement::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void FromStatement::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// WhileStatement member functions definition
    ///
 
      
 
      
      
 
      
 
    void WhileStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        condition->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void WhileStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        condition->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void WhileStatement::accept(visitor::Visitor& v) {
        v.visit_while_statement(*this);
    }
 
    void WhileStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_while_statement(*this);
    }
 
 
    WhileStatement::WhileStatement(Expression* condition, StatementBlock* statement_block)
                : condition(condition), statement_block(statement_block) { set_parent_in_children(); }
 
 
        WhileStatement::WhileStatement(std::shared_ptr<Expression> condition, std::shared_ptr<StatementBlock> statement_block)
                : condition(condition), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    WhileStatement::WhileStatement(const WhileStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.condition) {
                this->condition.reset(obj.condition->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void WhileStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (condition) {
                condition->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void WhileStatement::set_condition(std::shared_ptr<Expression>&& condition) {
                           this->condition = condition;
                           // set parents
                           if (condition) {
                               condition->set_parent(this);
                           }
                       }
 
                       void WhileStatement::set_condition(const std::shared_ptr<Expression>& condition) {
                           this->condition = condition;
                           // set parents
                           if (condition) {
                               condition->set_parent(this);
                           }
                       }
                    
    
                       void WhileStatement::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void WhileStatement::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// IfStatement member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
      
 
      
 
    void IfStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        condition->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->elseifs) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->elses) {
            this->elses->accept(v);
        }
        (void)v;
    }
 
    void IfStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        condition->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->elseifs) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->elses) {
            this->elses->accept(v);
        }
        (void)v;
    }
 
    void IfStatement::accept(visitor::Visitor& v) {
        v.visit_if_statement(*this);
    }
 
    void IfStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_if_statement(*this);
    }
 
 
    IfStatement::IfStatement(Expression* condition, StatementBlock* statement_block, const ElseIfStatementVector& elseifs, ElseStatement* elses)
                : condition(condition), statement_block(statement_block), elseifs(elseifs), elses(elses) { set_parent_in_children(); }
 
 
        IfStatement::IfStatement(std::shared_ptr<Expression> condition, std::shared_ptr<StatementBlock> statement_block, const ElseIfStatementVector& elseifs, std::shared_ptr<ElseStatement> elses)
                : condition(condition), statement_block(statement_block), elseifs(elseifs), elses(elses) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    IfStatement::IfStatement(const IfStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.condition) {
                this->condition.reset(obj.condition->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.elseifs) {
                this->elseifs.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.elses) {
                this->elses.reset(obj.elses->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void IfStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (condition) {
                condition->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : elseifs) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (elses) {
                elses->set_parent(this);
            }
 
    }
 
 
    
                       void IfStatement::set_condition(std::shared_ptr<Expression>&& condition) {
                           this->condition = condition;
                           // set parents
                           if (condition) {
                               condition->set_parent(this);
                           }
                       }
 
                       void IfStatement::set_condition(const std::shared_ptr<Expression>& condition) {
                           this->condition = condition;
                           // set parents
                           if (condition) {
                               condition->set_parent(this);
                           }
                       }
                    
    
                       void IfStatement::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void IfStatement::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
    
                       void IfStatement::set_elseifs(ElseIfStatementVector&& elseifs) {
                           this->elseifs = elseifs;
                           // set parents
                           for (auto& ii : elseifs) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void IfStatement::set_elseifs(const ElseIfStatementVector& elseifs) {
                           this->elseifs = elseifs;
                           // set parents
                           for (auto& ii : elseifs) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void IfStatement::set_elses(std::shared_ptr<ElseStatement>&& elses) {
                           this->elses = elses;
                           // set parents
                           if (elses) {
                               elses->set_parent(this);
                           }
                       }
 
                       void IfStatement::set_elses(const std::shared_ptr<ElseStatement>& elses) {
                           this->elses = elses;
                           // set parents
                           if (elses) {
                               elses->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ElseIfStatement member functions definition
    ///
 
      
 
      
      
 
      
 
    void ElseIfStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        condition->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ElseIfStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        condition->accept(v);
        (void)v;
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ElseIfStatement::accept(visitor::Visitor& v) {
        v.visit_else_if_statement(*this);
    }
 
    void ElseIfStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_else_if_statement(*this);
    }
 
 
    ElseIfStatement::ElseIfStatement(Expression* condition, StatementBlock* statement_block)
                : condition(condition), statement_block(statement_block) { set_parent_in_children(); }
 
 
        ElseIfStatement::ElseIfStatement(std::shared_ptr<Expression> condition, std::shared_ptr<StatementBlock> statement_block)
                : condition(condition), statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ElseIfStatement::ElseIfStatement(const ElseIfStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.condition) {
                this->condition.reset(obj.condition->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ElseIfStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (condition) {
                condition->set_parent(this);
            }
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void ElseIfStatement::set_condition(std::shared_ptr<Expression>&& condition) {
                           this->condition = condition;
                           // set parents
                           if (condition) {
                               condition->set_parent(this);
                           }
                       }
 
                       void ElseIfStatement::set_condition(const std::shared_ptr<Expression>& condition) {
                           this->condition = condition;
                           // set parents
                           if (condition) {
                               condition->set_parent(this);
                           }
                       }
                    
    
                       void ElseIfStatement::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void ElseIfStatement::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ElseStatement member functions definition
    ///
 
      
 
      
 
    void ElseStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ElseStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement_block->accept(v);
        (void)v;
    }
 
    void ElseStatement::accept(visitor::Visitor& v) {
        v.visit_else_statement(*this);
    }
 
    void ElseStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_else_statement(*this);
    }
 
 
    ElseStatement::ElseStatement(StatementBlock* statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
        ElseStatement::ElseStatement(std::shared_ptr<StatementBlock> statement_block)
                : statement_block(statement_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ElseStatement::ElseStatement(const ElseStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement_block) {
                this->statement_block.reset(obj.statement_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ElseStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement_block) {
                statement_block->set_parent(this);
            }
 
    }
 
 
    
                       void ElseStatement::set_statement_block(std::shared_ptr<StatementBlock>&& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
 
                       void ElseStatement::set_statement_block(const std::shared_ptr<StatementBlock>& statement_block) {
                           this->statement_block = statement_block;
                           // set parents
                           if (statement_block) {
                               statement_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// WatchStatement member functions definition
    ///
 
      
/**
 * \brief Add member to statements by raw pointer
 */
void WatchStatement::emplace_back_watch(Watch *n) {
   statements.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to statements by shared_ptr
 */
void WatchStatement::emplace_back_watch(std::shared_ptr<Watch> n) {
   statements.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to statements
 */
WatchVector::const_iterator WatchStatement::erase_watch(WatchVector::const_iterator first) {
   return statements.erase(first);
}
/**
 * \brief Erase members to statements
 */
WatchVector::const_iterator WatchStatement::erase_watch(WatchVector::const_iterator first, WatchVector::const_iterator last) {
   return statements.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to statements
 *
 * loosely following the cpp reference of remove_if
 */
size_t WatchStatement::erase_watch(std::unordered_set<Watch*>& to_be_erased) {
   auto first = statements.begin();
   auto last = statements.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_watch(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_watch(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to statements
 */
WatchVector::const_iterator WatchStatement::insert_watch(WatchVector::const_iterator position, const std::shared_ptr<Watch>& n) {
    n->set_parent(this); 
   return statements.insert(position, n);
}
 
/**
 * \brief Reset member to statements
 */
void WatchStatement::reset_watch(WatchVector::const_iterator position, Watch* n) {
    //set parents
    n->set_parent(this); 
 
   statements[position - statements.begin()].reset(n);
}
 
/**
 * \brief Reset member to statements
 */
void WatchStatement::reset_watch(WatchVector::const_iterator position, std::shared_ptr<Watch> n) {
    //set parents
    n->set_parent(this); 
 
   statements[position - statements.begin()] = n;
}
 
 
      
 
    void WatchStatement::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void WatchStatement::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void WatchStatement::accept(visitor::Visitor& v) {
        v.visit_watch_statement(*this);
    }
 
    void WatchStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_watch_statement(*this);
    }
 
 
    WatchStatement::WatchStatement(const WatchVector& statements)
                : statements(statements) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    WatchStatement::WatchStatement(const WatchStatement& obj) {
            /// copy each element of vector
            for (auto& item : obj.statements) {
                this->statements.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void WatchStatement::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : statements) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void WatchStatement::set_statements(WatchVector&& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void WatchStatement::set_statements(const WatchVector& statements) {
                           this->statements = statements;
                           // set parents
                           for (auto& ii : statements) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// MutexLock member functions definition
    ///
 
 
    void MutexLock::visit_children(visitor::Visitor& v) {
    }
 
    void MutexLock::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void MutexLock::accept(visitor::Visitor& v) {
        v.visit_mutex_lock(*this);
    }
 
    void MutexLock::accept(visitor::ConstVisitor& v) const {
        v.visit_mutex_lock(*this);
    }
 
 
 
 
    ///
    /// MutexUnlock member functions definition
    ///
 
 
    void MutexUnlock::visit_children(visitor::Visitor& v) {
    }
 
    void MutexUnlock::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void MutexUnlock::accept(visitor::Visitor& v) {
        v.visit_mutex_unlock(*this);
    }
 
    void MutexUnlock::accept(visitor::ConstVisitor& v) const {
        v.visit_mutex_unlock(*this);
    }
 
 
 
 
    ///
    /// Conserve member functions definition
    ///
 
      
 
      
      
 
      
 
    void Conserve::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        react->accept(v);
        (void)v;
        /// use -> for pointer member
        expr->accept(v);
        (void)v;
    }
 
    void Conserve::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        react->accept(v);
        (void)v;
        /// use -> for pointer member
        expr->accept(v);
        (void)v;
    }
 
    void Conserve::accept(visitor::Visitor& v) {
        v.visit_conserve(*this);
    }
 
    void Conserve::accept(visitor::ConstVisitor& v) const {
        v.visit_conserve(*this);
    }
 
 
    Conserve::Conserve(Expression* react, Expression* expr)
                : react(react), expr(expr) { set_parent_in_children(); }
 
 
        Conserve::Conserve(std::shared_ptr<Expression> react, std::shared_ptr<Expression> expr)
                : react(react), expr(expr) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Conserve::Conserve(const Conserve& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.react) {
                this->react.reset(obj.react->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.expr) {
                this->expr.reset(obj.expr->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Conserve::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (react) {
                react->set_parent(this);
            }
            /// optional member could be nullptr
            if (expr) {
                expr->set_parent(this);
            }
 
    }
 
 
    
                       void Conserve::set_react(std::shared_ptr<Expression>&& react) {
                           this->react = react;
                           // set parents
                           if (react) {
                               react->set_parent(this);
                           }
                       }
 
                       void Conserve::set_react(const std::shared_ptr<Expression>& react) {
                           this->react = react;
                           // set parents
                           if (react) {
                               react->set_parent(this);
                           }
                       }
                    
    
                       void Conserve::set_expr(std::shared_ptr<Expression>&& expr) {
                           this->expr = expr;
                           // set parents
                           if (expr) {
                               expr->set_parent(this);
                           }
                       }
 
                       void Conserve::set_expr(const std::shared_ptr<Expression>& expr) {
                           this->expr = expr;
                           // set parents
                           if (expr) {
                               expr->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Compartment member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
 
    void Compartment::visit_children(visitor::Visitor& v) {
        /// optional member could be nullptr
        if (this->index_name) {
            this->index_name->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        volume->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->species) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Compartment::visit_children(visitor::ConstVisitor& v) const {
        /// optional member could be nullptr
        if (this->index_name) {
            this->index_name->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        volume->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->species) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Compartment::accept(visitor::Visitor& v) {
        v.visit_compartment(*this);
    }
 
    void Compartment::accept(visitor::ConstVisitor& v) const {
        v.visit_compartment(*this);
    }
 
 
    Compartment::Compartment(Name* index_name, Expression* volume, const NameVector& species)
                : index_name(index_name), volume(volume), species(species) { set_parent_in_children(); }
 
 
        Compartment::Compartment(std::shared_ptr<Name> index_name, std::shared_ptr<Expression> volume, const NameVector& species)
                : index_name(index_name), volume(volume), species(species) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Compartment::Compartment(const Compartment& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.index_name) {
                this->index_name.reset(obj.index_name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.volume) {
                this->volume.reset(obj.volume->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.species) {
                this->species.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Compartment::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (index_name) {
                index_name->set_parent(this);
            }
            /// optional member could be nullptr
            if (volume) {
                volume->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : species) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Compartment::set_index_name(std::shared_ptr<Name>&& index_name) {
                           this->index_name = index_name;
                           // set parents
                           if (index_name) {
                               index_name->set_parent(this);
                           }
                       }
 
                       void Compartment::set_index_name(const std::shared_ptr<Name>& index_name) {
                           this->index_name = index_name;
                           // set parents
                           if (index_name) {
                               index_name->set_parent(this);
                           }
                       }
                    
    
                       void Compartment::set_volume(std::shared_ptr<Expression>&& volume) {
                           this->volume = volume;
                           // set parents
                           if (volume) {
                               volume->set_parent(this);
                           }
                       }
 
                       void Compartment::set_volume(const std::shared_ptr<Expression>& volume) {
                           this->volume = volume;
                           // set parents
                           if (volume) {
                               volume->set_parent(this);
                           }
                       }
                    
    
                       void Compartment::set_species(NameVector&& species) {
                           this->species = species;
                           // set parents
                           for (auto& ii : species) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Compartment::set_species(const NameVector& species) {
                           this->species = species;
                           // set parents
                           for (auto& ii : species) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// LonDiffuse member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
 
    void LonDiffuse::visit_children(visitor::Visitor& v) {
        /// optional member could be nullptr
        if (this->index_name) {
            this->index_name->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        rate->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->species) {
            item->accept(v);
        }
        (void)v;
    }
 
    void LonDiffuse::visit_children(visitor::ConstVisitor& v) const {
        /// optional member could be nullptr
        if (this->index_name) {
            this->index_name->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        rate->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->species) {
            item->accept(v);
        }
        (void)v;
    }
 
    void LonDiffuse::accept(visitor::Visitor& v) {
        v.visit_lon_diffuse(*this);
    }
 
    void LonDiffuse::accept(visitor::ConstVisitor& v) const {
        v.visit_lon_diffuse(*this);
    }
 
 
    LonDiffuse::LonDiffuse(Name* index_name, Expression* rate, const NameVector& species)
                : index_name(index_name), rate(rate), species(species) { set_parent_in_children(); }
 
 
        LonDiffuse::LonDiffuse(std::shared_ptr<Name> index_name, std::shared_ptr<Expression> rate, const NameVector& species)
                : index_name(index_name), rate(rate), species(species) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LonDiffuse::LonDiffuse(const LonDiffuse& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.index_name) {
                this->index_name.reset(obj.index_name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.rate) {
                this->rate.reset(obj.rate->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.species) {
                this->species.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LonDiffuse::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (index_name) {
                index_name->set_parent(this);
            }
            /// optional member could be nullptr
            if (rate) {
                rate->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : species) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void LonDiffuse::set_index_name(std::shared_ptr<Name>&& index_name) {
                           this->index_name = index_name;
                           // set parents
                           if (index_name) {
                               index_name->set_parent(this);
                           }
                       }
 
                       void LonDiffuse::set_index_name(const std::shared_ptr<Name>& index_name) {
                           this->index_name = index_name;
                           // set parents
                           if (index_name) {
                               index_name->set_parent(this);
                           }
                       }
                    
    
                       void LonDiffuse::set_rate(std::shared_ptr<Expression>&& rate) {
                           this->rate = rate;
                           // set parents
                           if (rate) {
                               rate->set_parent(this);
                           }
                       }
 
                       void LonDiffuse::set_rate(const std::shared_ptr<Expression>& rate) {
                           this->rate = rate;
                           // set parents
                           if (rate) {
                               rate->set_parent(this);
                           }
                       }
                    
    
                       void LonDiffuse::set_species(NameVector&& species) {
                           this->species = species;
                           // set parents
                           for (auto& ii : species) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void LonDiffuse::set_species(const NameVector& species) {
                           this->species = species;
                           // set parents
                           for (auto& ii : species) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// ReactionStatement member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
 
    void ReactionStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        reaction1->accept(v);
        (void)v;
        /// use . for object member
        op.accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->reaction2) {
            this->reaction2->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        expression1->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->expression2) {
            this->expression2->accept(v);
        }
        (void)v;
    }
 
    void ReactionStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        reaction1->accept(v);
        (void)v;
        /// use . for object member
        op.accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->reaction2) {
            this->reaction2->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        expression1->accept(v);
        (void)v;
        /// optional member could be nullptr
        if (this->expression2) {
            this->expression2->accept(v);
        }
        (void)v;
    }
 
    void ReactionStatement::accept(visitor::Visitor& v) {
        v.visit_reaction_statement(*this);
    }
 
    void ReactionStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_reaction_statement(*this);
    }
 
 
    ReactionStatement::ReactionStatement(Expression* reaction1, const ReactionOperator& op, Expression* reaction2, Expression* expression1, Expression* expression2)
                : reaction1(reaction1), op(op), reaction2(reaction2), expression1(expression1), expression2(expression2) { set_parent_in_children(); }
 
 
        ReactionStatement::ReactionStatement(std::shared_ptr<Expression> reaction1, const ReactionOperator& op, std::shared_ptr<Expression> reaction2, std::shared_ptr<Expression> expression1, std::shared_ptr<Expression> expression2)
                : reaction1(reaction1), op(op), reaction2(reaction2), expression1(expression1), expression2(expression2) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ReactionStatement::ReactionStatement(const ReactionStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.reaction1) {
                this->reaction1.reset(obj.reaction1->clone());
            }
            /// object member can be just copied by value
            this->op = obj.op;
            /// pointer member must be reseted with the new copy
            if (obj.reaction2) {
                this->reaction2.reset(obj.reaction2->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.expression1) {
                this->expression1.reset(obj.expression1->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.expression2) {
                this->expression2.reset(obj.expression2->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ReactionStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (reaction1) {
                reaction1->set_parent(this);
            }
                op.set_parent(this);
            /// optional member could be nullptr
            if (reaction2) {
                reaction2->set_parent(this);
            }
            /// optional member could be nullptr
            if (expression1) {
                expression1->set_parent(this);
            }
            /// optional member could be nullptr
            if (expression2) {
                expression2->set_parent(this);
            }
 
    }
 
 
    
                       void ReactionStatement::set_reaction1(std::shared_ptr<Expression>&& reaction1) {
                           this->reaction1 = reaction1;
                           // set parents
                           if (reaction1) {
                               reaction1->set_parent(this);
                           }
                       }
 
                       void ReactionStatement::set_reaction1(const std::shared_ptr<Expression>& reaction1) {
                           this->reaction1 = reaction1;
                           // set parents
                           if (reaction1) {
                               reaction1->set_parent(this);
                           }
                       }
                    
    
                       void ReactionStatement::set_op(ReactionOperator&& op) {
                           this->op = op;
                       }
 
                       void ReactionStatement::set_op(const ReactionOperator& op) {
                           this->op = op;
                       }
                    
    
                       void ReactionStatement::set_reaction2(std::shared_ptr<Expression>&& reaction2) {
                           this->reaction2 = reaction2;
                           // set parents
                           if (reaction2) {
                               reaction2->set_parent(this);
                           }
                       }
 
                       void ReactionStatement::set_reaction2(const std::shared_ptr<Expression>& reaction2) {
                           this->reaction2 = reaction2;
                           // set parents
                           if (reaction2) {
                               reaction2->set_parent(this);
                           }
                       }
                    
    
                       void ReactionStatement::set_expression1(std::shared_ptr<Expression>&& expression1) {
                           this->expression1 = expression1;
                           // set parents
                           if (expression1) {
                               expression1->set_parent(this);
                           }
                       }
 
                       void ReactionStatement::set_expression1(const std::shared_ptr<Expression>& expression1) {
                           this->expression1 = expression1;
                           // set parents
                           if (expression1) {
                               expression1->set_parent(this);
                           }
                       }
                    
    
                       void ReactionStatement::set_expression2(std::shared_ptr<Expression>&& expression2) {
                           this->expression2 = expression2;
                           // set parents
                           if (expression2) {
                               expression2->set_parent(this);
                           }
                       }
 
                       void ReactionStatement::set_expression2(const std::shared_ptr<Expression>& expression2) {
                           this->expression2 = expression2;
                           // set parents
                           if (expression2) {
                               expression2->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// LagStatement member functions definition
    ///
 
      
 
      
      
 
      
 
    void LagStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        byname->accept(v);
        (void)v;
    }
 
    void LagStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        byname->accept(v);
        (void)v;
    }
 
    void LagStatement::accept(visitor::Visitor& v) {
        v.visit_lag_statement(*this);
    }
 
    void LagStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_lag_statement(*this);
    }
 
 
    LagStatement::LagStatement(Identifier* name, Name* byname)
                : name(name), byname(byname) { set_parent_in_children(); }
 
 
        LagStatement::LagStatement(std::shared_ptr<Identifier> name, std::shared_ptr<Name> byname)
                : name(name), byname(byname) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LagStatement::LagStatement(const LagStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.byname) {
                this->byname.reset(obj.byname->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LagStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (byname) {
                byname->set_parent(this);
            }
 
    }
 
 
    
                       void LagStatement::set_name(std::shared_ptr<Identifier>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void LagStatement::set_name(const std::shared_ptr<Identifier>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void LagStatement::set_byname(std::shared_ptr<Name>&& byname) {
                           this->byname = byname;
                           // set parents
                           if (byname) {
                               byname->set_parent(this);
                           }
                       }
 
                       void LagStatement::set_byname(const std::shared_ptr<Name>& byname) {
                           this->byname = byname;
                           // set parents
                           if (byname) {
                               byname->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// ConstantStatement member functions definition
    ///
 
      
 
      
 
    void ConstantStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        constant->accept(v);
        (void)v;
    }
 
    void ConstantStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        constant->accept(v);
        (void)v;
    }
 
    void ConstantStatement::accept(visitor::Visitor& v) {
        v.visit_constant_statement(*this);
    }
 
    void ConstantStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_constant_statement(*this);
    }
 
 
    ConstantStatement::ConstantStatement(ConstantVar* constant)
                : constant(constant) { set_parent_in_children(); }
 
 
        ConstantStatement::ConstantStatement(std::shared_ptr<ConstantVar> constant)
                : constant(constant) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    ConstantStatement::ConstantStatement(const ConstantStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.constant) {
                this->constant.reset(obj.constant->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ConstantStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (constant) {
                constant->set_parent(this);
            }
 
    }
 
 
    
                       void ConstantStatement::set_constant(std::shared_ptr<ConstantVar>&& constant) {
                           this->constant = constant;
                           // set parents
                           if (constant) {
                               constant->set_parent(this);
                           }
                       }
 
                       void ConstantStatement::set_constant(const std::shared_ptr<ConstantVar>& constant) {
                           this->constant = constant;
                           // set parents
                           if (constant) {
                               constant->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// TableStatement member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
 
    void TableStatement::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->table_vars) {
            item->accept(v);
        }
        (void)v;
        /// visit each element of vector
        for (auto& item : this->depend_vars) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        from->accept(v);
        (void)v;
        /// use -> for pointer member
        to->accept(v);
        (void)v;
        /// use -> for pointer member
        with->accept(v);
        (void)v;
    }
 
    void TableStatement::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->table_vars) {
            item->accept(v);
        }
        (void)v;
        /// visit each element of vector
        for (auto& item : this->depend_vars) {
            item->accept(v);
        }
        (void)v;
        /// use -> for pointer member
        from->accept(v);
        (void)v;
        /// use -> for pointer member
        to->accept(v);
        (void)v;
        /// use -> for pointer member
        with->accept(v);
        (void)v;
    }
 
    void TableStatement::accept(visitor::Visitor& v) {
        v.visit_table_statement(*this);
    }
 
    void TableStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_table_statement(*this);
    }
 
 
    TableStatement::TableStatement(const NameVector& table_vars, const NameVector& depend_vars, Expression* from, Expression* to, Integer* with)
                : table_vars(table_vars), depend_vars(depend_vars), from(from), to(to), with(with) { set_parent_in_children(); }
 
 
        TableStatement::TableStatement(const NameVector& table_vars, const NameVector& depend_vars, std::shared_ptr<Expression> from, std::shared_ptr<Expression> to, std::shared_ptr<Integer> with)
                : table_vars(table_vars), depend_vars(depend_vars), from(from), to(to), with(with) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    TableStatement::TableStatement(const TableStatement& obj) {
            /// copy each element of vector
            for (auto& item : obj.table_vars) {
                this->table_vars.emplace_back(item->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.depend_vars) {
                this->depend_vars.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.from) {
                this->from.reset(obj.from->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.to) {
                this->to.reset(obj.to->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.with) {
                this->with.reset(obj.with->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void TableStatement::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : table_vars) {
                    item->set_parent(this);
 
            }
            /// set parent for each element of the vector
            for (auto& item : depend_vars) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (from) {
                from->set_parent(this);
            }
            /// optional member could be nullptr
            if (to) {
                to->set_parent(this);
            }
            /// optional member could be nullptr
            if (with) {
                with->set_parent(this);
            }
 
    }
 
 
    
                       void TableStatement::set_table_vars(NameVector&& table_vars) {
                           this->table_vars = table_vars;
                           // set parents
                           for (auto& ii : table_vars) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void TableStatement::set_table_vars(const NameVector& table_vars) {
                           this->table_vars = table_vars;
                           // set parents
                           for (auto& ii : table_vars) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void TableStatement::set_depend_vars(NameVector&& depend_vars) {
                           this->depend_vars = depend_vars;
                           // set parents
                           for (auto& ii : depend_vars) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void TableStatement::set_depend_vars(const NameVector& depend_vars) {
                           this->depend_vars = depend_vars;
                           // set parents
                           for (auto& ii : depend_vars) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void TableStatement::set_from(std::shared_ptr<Expression>&& from) {
                           this->from = from;
                           // set parents
                           if (from) {
                               from->set_parent(this);
                           }
                       }
 
                       void TableStatement::set_from(const std::shared_ptr<Expression>& from) {
                           this->from = from;
                           // set parents
                           if (from) {
                               from->set_parent(this);
                           }
                       }
                    
    
                       void TableStatement::set_to(std::shared_ptr<Expression>&& to) {
                           this->to = to;
                           // set parents
                           if (to) {
                               to->set_parent(this);
                           }
                       }
 
                       void TableStatement::set_to(const std::shared_ptr<Expression>& to) {
                           this->to = to;
                           // set parents
                           if (to) {
                               to->set_parent(this);
                           }
                       }
                    
    
                       void TableStatement::set_with(std::shared_ptr<Integer>&& with) {
                           this->with = with;
                           // set parents
                           if (with) {
                               with->set_parent(this);
                           }
                       }
 
                       void TableStatement::set_with(const std::shared_ptr<Integer>& with) {
                           this->with = with;
                           // set parents
                           if (with) {
                               with->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Suffix member functions definition
    ///
 
      
 
      
      
 
      std::string Suffix::get_node_name() const {
                             return name->get_node_name();
                         }
 
    void Suffix::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        type->accept(v);
        (void)v;
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void Suffix::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        type->accept(v);
        (void)v;
        /// use -> for pointer member
        name->accept(v);
        (void)v;
    }
 
    void Suffix::accept(visitor::Visitor& v) {
        v.visit_suffix(*this);
    }
 
    void Suffix::accept(visitor::ConstVisitor& v) const {
        v.visit_suffix(*this);
    }
 
 
    Suffix::Suffix(Name* type, Name* name)
                : type(type), name(name) { set_parent_in_children(); }
 
 
        Suffix::Suffix(std::shared_ptr<Name> type, std::shared_ptr<Name> name)
                : type(type), name(name) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Suffix::Suffix(const Suffix& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.type) {
                this->type.reset(obj.type->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Suffix::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (type) {
                type->set_parent(this);
            }
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
 
    }
 
 
    
                       void Suffix::set_type(std::shared_ptr<Name>&& type) {
                           this->type = type;
                           // set parents
                           if (type) {
                               type->set_parent(this);
                           }
                       }
 
                       void Suffix::set_type(const std::shared_ptr<Name>& type) {
                           this->type = type;
                           // set parents
                           if (type) {
                               type->set_parent(this);
                           }
                       }
                    
    
                       void Suffix::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void Suffix::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Useion member functions definition
    ///
 
      
 
      std::string Useion::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
      
 
      
 
    void Useion::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->readlist) {
            item->accept(v);
        }
        (void)v;
        /// visit each element of vector
        for (auto& item : this->writelist) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->valence) {
            this->valence->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->ontology_id) {
            this->ontology_id->accept(v);
        }
        (void)v;
    }
 
    void Useion::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->readlist) {
            item->accept(v);
        }
        (void)v;
        /// visit each element of vector
        for (auto& item : this->writelist) {
            item->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->valence) {
            this->valence->accept(v);
        }
        (void)v;
        /// optional member could be nullptr
        if (this->ontology_id) {
            this->ontology_id->accept(v);
        }
        (void)v;
    }
 
    void Useion::accept(visitor::Visitor& v) {
        v.visit_useion(*this);
    }
 
    void Useion::accept(visitor::ConstVisitor& v) const {
        v.visit_useion(*this);
    }
 
 
    Useion::Useion(Name* name, const ReadIonVarVector& readlist, const WriteIonVarVector& writelist, Valence* valence, String* ontology_id)
                : name(name), readlist(readlist), writelist(writelist), valence(valence), ontology_id(ontology_id) { set_parent_in_children(); }
 
 
        Useion::Useion(std::shared_ptr<Name> name, const ReadIonVarVector& readlist, const WriteIonVarVector& writelist, std::shared_ptr<Valence> valence, std::shared_ptr<String> ontology_id)
                : name(name), readlist(readlist), writelist(writelist), valence(valence), ontology_id(ontology_id) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Useion::Useion(const Useion& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.readlist) {
                this->readlist.emplace_back(item->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.writelist) {
                this->writelist.emplace_back(item->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.valence) {
                this->valence.reset(obj.valence->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.ontology_id) {
                this->ontology_id.reset(obj.ontology_id->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Useion::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : readlist) {
                    item->set_parent(this);
 
            }
            /// set parent for each element of the vector
            for (auto& item : writelist) {
                    item->set_parent(this);
 
            }
            /// optional member could be nullptr
            if (valence) {
                valence->set_parent(this);
            }
            /// optional member could be nullptr
            if (ontology_id) {
                ontology_id->set_parent(this);
            }
 
    }
 
 
    
                       void Useion::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void Useion::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void Useion::set_readlist(ReadIonVarVector&& readlist) {
                           this->readlist = readlist;
                           // set parents
                           for (auto& ii : readlist) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Useion::set_readlist(const ReadIonVarVector& readlist) {
                           this->readlist = readlist;
                           // set parents
                           for (auto& ii : readlist) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void Useion::set_writelist(WriteIonVarVector&& writelist) {
                           this->writelist = writelist;
                           // set parents
                           for (auto& ii : writelist) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Useion::set_writelist(const WriteIonVarVector& writelist) {
                           this->writelist = writelist;
                           // set parents
                           for (auto& ii : writelist) {
                                   ii->set_parent(this);
                            }
                       }
                    
    
                       void Useion::set_valence(std::shared_ptr<Valence>&& valence) {
                           this->valence = valence;
                           // set parents
                           if (valence) {
                               valence->set_parent(this);
                           }
                       }
 
                       void Useion::set_valence(const std::shared_ptr<Valence>& valence) {
                           this->valence = valence;
                           // set parents
                           if (valence) {
                               valence->set_parent(this);
                           }
                       }
                    
    
                       void Useion::set_ontology_id(std::shared_ptr<String>&& ontology_id) {
                           this->ontology_id = ontology_id;
                           // set parents
                           if (ontology_id) {
                               ontology_id->set_parent(this);
                           }
                       }
 
                       void Useion::set_ontology_id(const std::shared_ptr<String>& ontology_id) {
                           this->ontology_id = ontology_id;
                           // set parents
                           if (ontology_id) {
                               ontology_id->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Nonspecific member functions definition
    ///
 
      
 
      
 
    void Nonspecific::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->currents) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Nonspecific::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->currents) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Nonspecific::accept(visitor::Visitor& v) {
        v.visit_nonspecific(*this);
    }
 
    void Nonspecific::accept(visitor::ConstVisitor& v) const {
        v.visit_nonspecific(*this);
    }
 
 
    Nonspecific::Nonspecific(const NonspecificCurVarVector& currents)
                : currents(currents) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Nonspecific::Nonspecific(const Nonspecific& obj) {
            /// copy each element of vector
            for (auto& item : obj.currents) {
                this->currents.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Nonspecific::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : currents) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Nonspecific::set_currents(NonspecificCurVarVector&& currents) {
                           this->currents = currents;
                           // set parents
                           for (auto& ii : currents) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Nonspecific::set_currents(const NonspecificCurVarVector& currents) {
                           this->currents = currents;
                           // set parents
                           for (auto& ii : currents) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// ElectrodeCurrent member functions definition
    ///
 
      
 
      
 
    void ElectrodeCurrent::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->currents) {
            item->accept(v);
        }
        (void)v;
    }
 
    void ElectrodeCurrent::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->currents) {
            item->accept(v);
        }
        (void)v;
    }
 
    void ElectrodeCurrent::accept(visitor::Visitor& v) {
        v.visit_electrode_current(*this);
    }
 
    void ElectrodeCurrent::accept(visitor::ConstVisitor& v) const {
        v.visit_electrode_current(*this);
    }
 
 
    ElectrodeCurrent::ElectrodeCurrent(const ElectrodeCurVarVector& currents)
                : currents(currents) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    ElectrodeCurrent::ElectrodeCurrent(const ElectrodeCurrent& obj) {
            /// copy each element of vector
            for (auto& item : obj.currents) {
                this->currents.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void ElectrodeCurrent::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : currents) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void ElectrodeCurrent::set_currents(ElectrodeCurVarVector&& currents) {
                           this->currents = currents;
                           // set parents
                           for (auto& ii : currents) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void ElectrodeCurrent::set_currents(const ElectrodeCurVarVector& currents) {
                           this->currents = currents;
                           // set parents
                           for (auto& ii : currents) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// Range member functions definition
    ///
 
      
 
      
 
    void Range::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Range::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Range::accept(visitor::Visitor& v) {
        v.visit_range(*this);
    }
 
    void Range::accept(visitor::ConstVisitor& v) const {
        v.visit_range(*this);
    }
 
 
    Range::Range(const RangeVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Range::Range(const Range& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Range::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Range::set_variables(RangeVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Range::set_variables(const RangeVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// Global member functions definition
    ///
 
      
/**
 * \brief Add member to variables by raw pointer
 */
void Global::emplace_back_global_var(GlobalVar *n) {
   variables.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to variables by shared_ptr
 */
void Global::emplace_back_global_var(std::shared_ptr<GlobalVar> n) {
   variables.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to variables
 */
GlobalVarVector::const_iterator Global::erase_global_var(GlobalVarVector::const_iterator first) {
   return variables.erase(first);
}
/**
 * \brief Erase members to variables
 */
GlobalVarVector::const_iterator Global::erase_global_var(GlobalVarVector::const_iterator first, GlobalVarVector::const_iterator last) {
   return variables.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to variables
 *
 * loosely following the cpp reference of remove_if
 */
size_t Global::erase_global_var(std::unordered_set<GlobalVar*>& to_be_erased) {
   auto first = variables.begin();
   auto last = variables.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_global_var(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_global_var(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to variables
 */
GlobalVarVector::const_iterator Global::insert_global_var(GlobalVarVector::const_iterator position, const std::shared_ptr<GlobalVar>& n) {
    n->set_parent(this); 
   return variables.insert(position, n);
}
 
/**
 * \brief Reset member to variables
 */
void Global::reset_global_var(GlobalVarVector::const_iterator position, GlobalVar* n) {
    //set parents
    n->set_parent(this); 
 
   variables[position - variables.begin()].reset(n);
}
 
/**
 * \brief Reset member to variables
 */
void Global::reset_global_var(GlobalVarVector::const_iterator position, std::shared_ptr<GlobalVar> n) {
    //set parents
    n->set_parent(this); 
 
   variables[position - variables.begin()] = n;
}
 
 
      
 
    void Global::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Global::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Global::accept(visitor::Visitor& v) {
        v.visit_global(*this);
    }
 
    void Global::accept(visitor::ConstVisitor& v) const {
        v.visit_global(*this);
    }
 
 
    Global::Global(const GlobalVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Global::Global(const Global& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Global::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Global::set_variables(GlobalVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Global::set_variables(const GlobalVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// RandomVarList member functions definition
    ///
 
      
 
      
 
    void RandomVarList::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void RandomVarList::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void RandomVarList::accept(visitor::Visitor& v) {
        v.visit_random_var_list(*this);
    }
 
    void RandomVarList::accept(visitor::ConstVisitor& v) const {
        v.visit_random_var_list(*this);
    }
 
 
    RandomVarList::RandomVarList(const RandomVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    RandomVarList::RandomVarList(const RandomVarList& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void RandomVarList::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void RandomVarList::set_variables(RandomVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void RandomVarList::set_variables(const RandomVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// Pointer member functions definition
    ///
 
      
/**
 * \brief Add member to variables by raw pointer
 */
void Pointer::emplace_back_pointer_var(PointerVar *n) {
   variables.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to variables by shared_ptr
 */
void Pointer::emplace_back_pointer_var(std::shared_ptr<PointerVar> n) {
   variables.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to variables
 */
PointerVarVector::const_iterator Pointer::erase_pointer_var(PointerVarVector::const_iterator first) {
   return variables.erase(first);
}
/**
 * \brief Erase members to variables
 */
PointerVarVector::const_iterator Pointer::erase_pointer_var(PointerVarVector::const_iterator first, PointerVarVector::const_iterator last) {
   return variables.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to variables
 *
 * loosely following the cpp reference of remove_if
 */
size_t Pointer::erase_pointer_var(std::unordered_set<PointerVar*>& to_be_erased) {
   auto first = variables.begin();
   auto last = variables.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_pointer_var(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_pointer_var(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to variables
 */
PointerVarVector::const_iterator Pointer::insert_pointer_var(PointerVarVector::const_iterator position, const std::shared_ptr<PointerVar>& n) {
    n->set_parent(this); 
   return variables.insert(position, n);
}
 
/**
 * \brief Reset member to variables
 */
void Pointer::reset_pointer_var(PointerVarVector::const_iterator position, PointerVar* n) {
    //set parents
    n->set_parent(this); 
 
   variables[position - variables.begin()].reset(n);
}
 
/**
 * \brief Reset member to variables
 */
void Pointer::reset_pointer_var(PointerVarVector::const_iterator position, std::shared_ptr<PointerVar> n) {
    //set parents
    n->set_parent(this); 
 
   variables[position - variables.begin()] = n;
}
 
 
      
 
    void Pointer::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Pointer::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Pointer::accept(visitor::Visitor& v) {
        v.visit_pointer(*this);
    }
 
    void Pointer::accept(visitor::ConstVisitor& v) const {
        v.visit_pointer(*this);
    }
 
 
    Pointer::Pointer(const PointerVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Pointer::Pointer(const Pointer& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Pointer::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Pointer::set_variables(PointerVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Pointer::set_variables(const PointerVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// BbcorePointer member functions definition
    ///
 
      
 
      
 
    void BbcorePointer::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void BbcorePointer::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void BbcorePointer::accept(visitor::Visitor& v) {
        v.visit_bbcore_pointer(*this);
    }
 
    void BbcorePointer::accept(visitor::ConstVisitor& v) const {
        v.visit_bbcore_pointer(*this);
    }
 
 
    BbcorePointer::BbcorePointer(const BbcorePointerVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    BbcorePointer::BbcorePointer(const BbcorePointer& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BbcorePointer::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void BbcorePointer::set_variables(BbcorePointerVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void BbcorePointer::set_variables(const BbcorePointerVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// External member functions definition
    ///
 
      
 
      
 
    void External::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void External::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->variables) {
            item->accept(v);
        }
        (void)v;
    }
 
    void External::accept(visitor::Visitor& v) {
        v.visit_external(*this);
    }
 
    void External::accept(visitor::ConstVisitor& v) const {
        v.visit_external(*this);
    }
 
 
    External::External(const ExternVarVector& variables)
                : variables(variables) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    External::External(const External& obj) {
            /// copy each element of vector
            for (auto& item : obj.variables) {
                this->variables.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void External::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : variables) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void External::set_variables(ExternVarVector&& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void External::set_variables(const ExternVarVector& variables) {
                           this->variables = variables;
                           // set parents
                           for (auto& ii : variables) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// ThreadSafe member functions definition
    ///
 
 
    void ThreadSafe::visit_children(visitor::Visitor& v) {
    }
 
    void ThreadSafe::visit_children(visitor::ConstVisitor& v) const {
    }
 
    void ThreadSafe::accept(visitor::Visitor& v) {
        v.visit_thread_safe(*this);
    }
 
    void ThreadSafe::accept(visitor::ConstVisitor& v) const {
        v.visit_thread_safe(*this);
    }
 
 
 
 
    ///
    /// Verbatim member functions definition
    ///
 
      
 
      
 
    void Verbatim::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement->accept(v);
        (void)v;
    }
 
    void Verbatim::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement->accept(v);
        (void)v;
    }
 
    void Verbatim::accept(visitor::Visitor& v) {
        v.visit_verbatim(*this);
    }
 
    void Verbatim::accept(visitor::ConstVisitor& v) const {
        v.visit_verbatim(*this);
    }
 
 
    Verbatim::Verbatim(String* statement)
                : statement(statement) { set_parent_in_children(); }
 
 
        Verbatim::Verbatim(std::shared_ptr<String> statement)
                : statement(statement) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    Verbatim::Verbatim(const Verbatim& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement) {
                this->statement.reset(obj.statement->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Verbatim::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement) {
                statement->set_parent(this);
            }
 
    }
 
 
    
                       void Verbatim::set_statement(std::shared_ptr<String>&& statement) {
                           this->statement = statement;
                           // set parents
                           if (statement) {
                               statement->set_parent(this);
                           }
                       }
 
                       void Verbatim::set_statement(const std::shared_ptr<String>& statement) {
                           this->statement = statement;
                           // set parents
                           if (statement) {
                               statement->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// LineComment member functions definition
    ///
 
      
 
      
 
    void LineComment::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement->accept(v);
        (void)v;
    }
 
    void LineComment::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement->accept(v);
        (void)v;
    }
 
    void LineComment::accept(visitor::Visitor& v) {
        v.visit_line_comment(*this);
    }
 
    void LineComment::accept(visitor::ConstVisitor& v) const {
        v.visit_line_comment(*this);
    }
 
 
    LineComment::LineComment(String* statement)
                : statement(statement) { set_parent_in_children(); }
 
 
        LineComment::LineComment(std::shared_ptr<String> statement)
                : statement(statement) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LineComment::LineComment(const LineComment& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement) {
                this->statement.reset(obj.statement->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LineComment::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement) {
                statement->set_parent(this);
            }
 
    }
 
 
    
                       void LineComment::set_statement(std::shared_ptr<String>&& statement) {
                           this->statement = statement;
                           // set parents
                           if (statement) {
                               statement->set_parent(this);
                           }
                       }
 
                       void LineComment::set_statement(const std::shared_ptr<String>& statement) {
                           this->statement = statement;
                           // set parents
                           if (statement) {
                               statement->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// BlockComment member functions definition
    ///
 
      
 
      
 
    void BlockComment::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        statement->accept(v);
        (void)v;
    }
 
    void BlockComment::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        statement->accept(v);
        (void)v;
    }
 
    void BlockComment::accept(visitor::Visitor& v) {
        v.visit_block_comment(*this);
    }
 
    void BlockComment::accept(visitor::ConstVisitor& v) const {
        v.visit_block_comment(*this);
    }
 
 
    BlockComment::BlockComment(String* statement)
                : statement(statement) { set_parent_in_children(); }
 
 
        BlockComment::BlockComment(std::shared_ptr<String> statement)
                : statement(statement) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    BlockComment::BlockComment(const BlockComment& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.statement) {
                this->statement.reset(obj.statement->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void BlockComment::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (statement) {
                statement->set_parent(this);
            }
 
    }
 
 
    
                       void BlockComment::set_statement(std::shared_ptr<String>&& statement) {
                           this->statement = statement;
                           // set parents
                           if (statement) {
                               statement->set_parent(this);
                           }
                       }
 
                       void BlockComment::set_statement(const std::shared_ptr<String>& statement) {
                           this->statement = statement;
                           // set parents
                           if (statement) {
                               statement->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// OntologyStatement member functions definition
    ///
 
      
 
      
 
    void OntologyStatement::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        ontology_id->accept(v);
        (void)v;
    }
 
    void OntologyStatement::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        ontology_id->accept(v);
        (void)v;
    }
 
    void OntologyStatement::accept(visitor::Visitor& v) {
        v.visit_ontology_statement(*this);
    }
 
    void OntologyStatement::accept(visitor::ConstVisitor& v) const {
        v.visit_ontology_statement(*this);
    }
 
 
    OntologyStatement::OntologyStatement(String* ontology_id)
                : ontology_id(ontology_id) { set_parent_in_children(); }
 
 
        OntologyStatement::OntologyStatement(std::shared_ptr<String> ontology_id)
                : ontology_id(ontology_id) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    OntologyStatement::OntologyStatement(const OntologyStatement& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.ontology_id) {
                this->ontology_id.reset(obj.ontology_id->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void OntologyStatement::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (ontology_id) {
                ontology_id->set_parent(this);
            }
 
    }
 
 
    
                       void OntologyStatement::set_ontology_id(std::shared_ptr<String>&& ontology_id) {
                           this->ontology_id = ontology_id;
                           // set parents
                           if (ontology_id) {
                               ontology_id->set_parent(this);
                           }
                       }
 
                       void OntologyStatement::set_ontology_id(const std::shared_ptr<String>& ontology_id) {
                           this->ontology_id = ontology_id;
                           // set parents
                           if (ontology_id) {
                               ontology_id->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// Program member functions definition
    ///
 
      
/**
 * \brief Add member to blocks by raw pointer
 */
void Program::emplace_back_node(Node *n) {
   blocks.emplace_back(n);
 
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Add member to blocks by shared_ptr
 */
void Program::emplace_back_node(std::shared_ptr<Node> n) {
   blocks.emplace_back(n);
    // set parents
    n->set_parent(this); 
}
 
/**
 * \brief Erase member to blocks
 */
NodeVector::const_iterator Program::erase_node(NodeVector::const_iterator first) {
   return blocks.erase(first);
}
/**
 * \brief Erase members to blocks
 */
NodeVector::const_iterator Program::erase_node(NodeVector::const_iterator first, NodeVector::const_iterator last) {
   return blocks.erase(first, last);
}
/**
 * \brief Erase non-consecutive members to blocks
 *
 * loosely following the cpp reference of remove_if
 */
size_t Program::erase_node(std::unordered_set<Node*>& to_be_erased) {
   auto first = blocks.begin();
   auto last = blocks.end();
   auto result = first;
 
   while (first != last) {
           // automatically erase dangling pointers from the uset while
           // looking for them to erase them in the vector
           if (to_be_erased.erase(first->get()) == 0) {
               reset_node(result, *first);
               ++result;
           }
           ++first;
       }
 
   size_t out = last - result;
   erase_node(result, last);
 
   return out;
}
 
/**
 * \brief Insert member to blocks
 */
NodeVector::const_iterator Program::insert_node(NodeVector::const_iterator position, const std::shared_ptr<Node>& n) {
    n->set_parent(this); 
   return blocks.insert(position, n);
}
 
/**
 * \brief Reset member to blocks
 */
void Program::reset_node(NodeVector::const_iterator position, Node* n) {
    //set parents
    n->set_parent(this); 
 
   blocks[position - blocks.begin()].reset(n);
}
 
/**
 * \brief Reset member to blocks
 */
void Program::reset_node(NodeVector::const_iterator position, std::shared_ptr<Node> n) {
    //set parents
    n->set_parent(this); 
 
   blocks[position - blocks.begin()] = n;
}
 
 
      
 
    void Program::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->blocks) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Program::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->blocks) {
            item->accept(v);
        }
        (void)v;
    }
 
    void Program::accept(visitor::Visitor& v) {
        v.visit_program(*this);
    }
 
    void Program::accept(visitor::ConstVisitor& v) const {
        v.visit_program(*this);
    }
 
 
    Program::Program(const NodeVector& blocks)
                : blocks(blocks) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    Program::Program(const Program& obj) {
            /// copy each element of vector
            for (auto& item : obj.blocks) {
                this->blocks.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void Program::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : blocks) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void Program::set_blocks(NodeVector&& blocks) {
                           this->blocks = blocks;
                           // set parents
                           for (auto& ii : blocks) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void Program::set_blocks(const NodeVector& blocks) {
                           this->blocks = blocks;
                           // set parents
                           for (auto& ii : blocks) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// NrnStateBlock member functions definition
    ///
 
      
 
      
 
    void NrnStateBlock::visit_children(visitor::Visitor& v) {
        /// visit each element of vector
        for (auto& item : this->solve_statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void NrnStateBlock::visit_children(visitor::ConstVisitor& v) const {
        /// visit each element of vector
        for (auto& item : this->solve_statements) {
            item->accept(v);
        }
        (void)v;
    }
 
    void NrnStateBlock::accept(visitor::Visitor& v) {
        v.visit_nrn_state_block(*this);
    }
 
    void NrnStateBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_nrn_state_block(*this);
    }
 
 
    NrnStateBlock::NrnStateBlock(const StatementVector& solve_statements)
                : solve_statements(solve_statements) { set_parent_in_children(); }
 
 
 
    /// copy constructor implementation
    NrnStateBlock::NrnStateBlock(const NrnStateBlock& obj) {
            /// copy each element of vector
            for (auto& item : obj.solve_statements) {
                this->solve_statements.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void NrnStateBlock::set_parent_in_children() {
 
            /// set parent for each element of the vector
            for (auto& item : solve_statements) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void NrnStateBlock::set_solve_statements(StatementVector&& solve_statements) {
                           this->solve_statements = solve_statements;
                           // set parents
                           for (auto& ii : solve_statements) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void NrnStateBlock::set_solve_statements(const StatementVector& solve_statements) {
                           this->solve_statements = solve_statements;
                           // set parents
                           for (auto& ii : solve_statements) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// EigenNewtonSolverBlock member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
 
    void EigenNewtonSolverBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        n_state_vars->accept(v);
        (void)v;
        /// use -> for pointer member
        variable_block->accept(v);
        (void)v;
        /// use -> for pointer member
        initialize_block->accept(v);
        (void)v;
        /// use -> for pointer member
        setup_x_block->accept(v);
        (void)v;
        /// use -> for pointer member
        functor_block->accept(v);
        (void)v;
        /// use -> for pointer member
        update_states_block->accept(v);
        (void)v;
        /// use -> for pointer member
        finalize_block->accept(v);
        (void)v;
    }
 
    void EigenNewtonSolverBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        n_state_vars->accept(v);
        (void)v;
        /// use -> for pointer member
        variable_block->accept(v);
        (void)v;
        /// use -> for pointer member
        initialize_block->accept(v);
        (void)v;
        /// use -> for pointer member
        setup_x_block->accept(v);
        (void)v;
        /// use -> for pointer member
        functor_block->accept(v);
        (void)v;
        /// use -> for pointer member
        update_states_block->accept(v);
        (void)v;
        /// use -> for pointer member
        finalize_block->accept(v);
        (void)v;
    }
 
    void EigenNewtonSolverBlock::accept(visitor::Visitor& v) {
        v.visit_eigen_newton_solver_block(*this);
    }
 
    void EigenNewtonSolverBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_eigen_newton_solver_block(*this);
    }
 
 
    EigenNewtonSolverBlock::EigenNewtonSolverBlock(Integer* n_state_vars, StatementBlock* variable_block, StatementBlock* initialize_block, StatementBlock* setup_x_block, StatementBlock* functor_block, StatementBlock* update_states_block, StatementBlock* finalize_block)
                : n_state_vars(n_state_vars), variable_block(variable_block), initialize_block(initialize_block), setup_x_block(setup_x_block), functor_block(functor_block), update_states_block(update_states_block), finalize_block(finalize_block) { set_parent_in_children(); }
 
 
        EigenNewtonSolverBlock::EigenNewtonSolverBlock(std::shared_ptr<Integer> n_state_vars, std::shared_ptr<StatementBlock> variable_block, std::shared_ptr<StatementBlock> initialize_block, std::shared_ptr<StatementBlock> setup_x_block, std::shared_ptr<StatementBlock> functor_block, std::shared_ptr<StatementBlock> update_states_block, std::shared_ptr<StatementBlock> finalize_block)
                : n_state_vars(n_state_vars), variable_block(variable_block), initialize_block(initialize_block), setup_x_block(setup_x_block), functor_block(functor_block), update_states_block(update_states_block), finalize_block(finalize_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    EigenNewtonSolverBlock::EigenNewtonSolverBlock(const EigenNewtonSolverBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.n_state_vars) {
                this->n_state_vars.reset(obj.n_state_vars->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.variable_block) {
                this->variable_block.reset(obj.variable_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.initialize_block) {
                this->initialize_block.reset(obj.initialize_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.setup_x_block) {
                this->setup_x_block.reset(obj.setup_x_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.functor_block) {
                this->functor_block.reset(obj.functor_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.update_states_block) {
                this->update_states_block.reset(obj.update_states_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.finalize_block) {
                this->finalize_block.reset(obj.finalize_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void EigenNewtonSolverBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (n_state_vars) {
                n_state_vars->set_parent(this);
            }
            /// optional member could be nullptr
            if (variable_block) {
                variable_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (initialize_block) {
                initialize_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (setup_x_block) {
                setup_x_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (functor_block) {
                functor_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (update_states_block) {
                update_states_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (finalize_block) {
                finalize_block->set_parent(this);
            }
 
    }
 
 
    
                       void EigenNewtonSolverBlock::set_n_state_vars(std::shared_ptr<Integer>&& n_state_vars) {
                           this->n_state_vars = n_state_vars;
                           // set parents
                           if (n_state_vars) {
                               n_state_vars->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_n_state_vars(const std::shared_ptr<Integer>& n_state_vars) {
                           this->n_state_vars = n_state_vars;
                           // set parents
                           if (n_state_vars) {
                               n_state_vars->set_parent(this);
                           }
                       }
                    
    
                       void EigenNewtonSolverBlock::set_variable_block(std::shared_ptr<StatementBlock>&& variable_block) {
                           this->variable_block = variable_block;
                           // set parents
                           if (variable_block) {
                               variable_block->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_variable_block(const std::shared_ptr<StatementBlock>& variable_block) {
                           this->variable_block = variable_block;
                           // set parents
                           if (variable_block) {
                               variable_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenNewtonSolverBlock::set_initialize_block(std::shared_ptr<StatementBlock>&& initialize_block) {
                           this->initialize_block = initialize_block;
                           // set parents
                           if (initialize_block) {
                               initialize_block->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_initialize_block(const std::shared_ptr<StatementBlock>& initialize_block) {
                           this->initialize_block = initialize_block;
                           // set parents
                           if (initialize_block) {
                               initialize_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenNewtonSolverBlock::set_setup_x_block(std::shared_ptr<StatementBlock>&& setup_x_block) {
                           this->setup_x_block = setup_x_block;
                           // set parents
                           if (setup_x_block) {
                               setup_x_block->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_setup_x_block(const std::shared_ptr<StatementBlock>& setup_x_block) {
                           this->setup_x_block = setup_x_block;
                           // set parents
                           if (setup_x_block) {
                               setup_x_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenNewtonSolverBlock::set_functor_block(std::shared_ptr<StatementBlock>&& functor_block) {
                           this->functor_block = functor_block;
                           // set parents
                           if (functor_block) {
                               functor_block->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_functor_block(const std::shared_ptr<StatementBlock>& functor_block) {
                           this->functor_block = functor_block;
                           // set parents
                           if (functor_block) {
                               functor_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenNewtonSolverBlock::set_update_states_block(std::shared_ptr<StatementBlock>&& update_states_block) {
                           this->update_states_block = update_states_block;
                           // set parents
                           if (update_states_block) {
                               update_states_block->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_update_states_block(const std::shared_ptr<StatementBlock>& update_states_block) {
                           this->update_states_block = update_states_block;
                           // set parents
                           if (update_states_block) {
                               update_states_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenNewtonSolverBlock::set_finalize_block(std::shared_ptr<StatementBlock>&& finalize_block) {
                           this->finalize_block = finalize_block;
                           // set parents
                           if (finalize_block) {
                               finalize_block->set_parent(this);
                           }
                       }
 
                       void EigenNewtonSolverBlock::set_finalize_block(const std::shared_ptr<StatementBlock>& finalize_block) {
                           this->finalize_block = finalize_block;
                           // set parents
                           if (finalize_block) {
                               finalize_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// EigenLinearSolverBlock member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
      
 
      
 
    void EigenLinearSolverBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        n_state_vars->accept(v);
        (void)v;
        /// use -> for pointer member
        variable_block->accept(v);
        (void)v;
        /// use -> for pointer member
        initialize_block->accept(v);
        (void)v;
        /// use -> for pointer member
        setup_x_block->accept(v);
        (void)v;
        /// use -> for pointer member
        update_states_block->accept(v);
        (void)v;
        /// use -> for pointer member
        finalize_block->accept(v);
        (void)v;
    }
 
    void EigenLinearSolverBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        n_state_vars->accept(v);
        (void)v;
        /// use -> for pointer member
        variable_block->accept(v);
        (void)v;
        /// use -> for pointer member
        initialize_block->accept(v);
        (void)v;
        /// use -> for pointer member
        setup_x_block->accept(v);
        (void)v;
        /// use -> for pointer member
        update_states_block->accept(v);
        (void)v;
        /// use -> for pointer member
        finalize_block->accept(v);
        (void)v;
    }
 
    void EigenLinearSolverBlock::accept(visitor::Visitor& v) {
        v.visit_eigen_linear_solver_block(*this);
    }
 
    void EigenLinearSolverBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_eigen_linear_solver_block(*this);
    }
 
 
    EigenLinearSolverBlock::EigenLinearSolverBlock(Integer* n_state_vars, StatementBlock* variable_block, StatementBlock* initialize_block, StatementBlock* setup_x_block, StatementBlock* update_states_block, StatementBlock* finalize_block)
                : n_state_vars(n_state_vars), variable_block(variable_block), initialize_block(initialize_block), setup_x_block(setup_x_block), update_states_block(update_states_block), finalize_block(finalize_block) { set_parent_in_children(); }
 
 
        EigenLinearSolverBlock::EigenLinearSolverBlock(std::shared_ptr<Integer> n_state_vars, std::shared_ptr<StatementBlock> variable_block, std::shared_ptr<StatementBlock> initialize_block, std::shared_ptr<StatementBlock> setup_x_block, std::shared_ptr<StatementBlock> update_states_block, std::shared_ptr<StatementBlock> finalize_block)
                : n_state_vars(n_state_vars), variable_block(variable_block), initialize_block(initialize_block), setup_x_block(setup_x_block), update_states_block(update_states_block), finalize_block(finalize_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    EigenLinearSolverBlock::EigenLinearSolverBlock(const EigenLinearSolverBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.n_state_vars) {
                this->n_state_vars.reset(obj.n_state_vars->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.variable_block) {
                this->variable_block.reset(obj.variable_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.initialize_block) {
                this->initialize_block.reset(obj.initialize_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.setup_x_block) {
                this->setup_x_block.reset(obj.setup_x_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.update_states_block) {
                this->update_states_block.reset(obj.update_states_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.finalize_block) {
                this->finalize_block.reset(obj.finalize_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void EigenLinearSolverBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (n_state_vars) {
                n_state_vars->set_parent(this);
            }
            /// optional member could be nullptr
            if (variable_block) {
                variable_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (initialize_block) {
                initialize_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (setup_x_block) {
                setup_x_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (update_states_block) {
                update_states_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (finalize_block) {
                finalize_block->set_parent(this);
            }
 
    }
 
 
    
                       void EigenLinearSolverBlock::set_n_state_vars(std::shared_ptr<Integer>&& n_state_vars) {
                           this->n_state_vars = n_state_vars;
                           // set parents
                           if (n_state_vars) {
                               n_state_vars->set_parent(this);
                           }
                       }
 
                       void EigenLinearSolverBlock::set_n_state_vars(const std::shared_ptr<Integer>& n_state_vars) {
                           this->n_state_vars = n_state_vars;
                           // set parents
                           if (n_state_vars) {
                               n_state_vars->set_parent(this);
                           }
                       }
                    
    
                       void EigenLinearSolverBlock::set_variable_block(std::shared_ptr<StatementBlock>&& variable_block) {
                           this->variable_block = variable_block;
                           // set parents
                           if (variable_block) {
                               variable_block->set_parent(this);
                           }
                       }
 
                       void EigenLinearSolverBlock::set_variable_block(const std::shared_ptr<StatementBlock>& variable_block) {
                           this->variable_block = variable_block;
                           // set parents
                           if (variable_block) {
                               variable_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenLinearSolverBlock::set_initialize_block(std::shared_ptr<StatementBlock>&& initialize_block) {
                           this->initialize_block = initialize_block;
                           // set parents
                           if (initialize_block) {
                               initialize_block->set_parent(this);
                           }
                       }
 
                       void EigenLinearSolverBlock::set_initialize_block(const std::shared_ptr<StatementBlock>& initialize_block) {
                           this->initialize_block = initialize_block;
                           // set parents
                           if (initialize_block) {
                               initialize_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenLinearSolverBlock::set_setup_x_block(std::shared_ptr<StatementBlock>&& setup_x_block) {
                           this->setup_x_block = setup_x_block;
                           // set parents
                           if (setup_x_block) {
                               setup_x_block->set_parent(this);
                           }
                       }
 
                       void EigenLinearSolverBlock::set_setup_x_block(const std::shared_ptr<StatementBlock>& setup_x_block) {
                           this->setup_x_block = setup_x_block;
                           // set parents
                           if (setup_x_block) {
                               setup_x_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenLinearSolverBlock::set_update_states_block(std::shared_ptr<StatementBlock>&& update_states_block) {
                           this->update_states_block = update_states_block;
                           // set parents
                           if (update_states_block) {
                               update_states_block->set_parent(this);
                           }
                       }
 
                       void EigenLinearSolverBlock::set_update_states_block(const std::shared_ptr<StatementBlock>& update_states_block) {
                           this->update_states_block = update_states_block;
                           // set parents
                           if (update_states_block) {
                               update_states_block->set_parent(this);
                           }
                       }
                    
    
                       void EigenLinearSolverBlock::set_finalize_block(std::shared_ptr<StatementBlock>&& finalize_block) {
                           this->finalize_block = finalize_block;
                           // set parents
                           if (finalize_block) {
                               finalize_block->set_parent(this);
                           }
                       }
 
                       void EigenLinearSolverBlock::set_finalize_block(const std::shared_ptr<StatementBlock>& finalize_block) {
                           this->finalize_block = finalize_block;
                           // set parents
                           if (finalize_block) {
                               finalize_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// MatexpBlock member functions definition
    ///
 
      
 
      
      
 
      
      
 
      
 
    void MatexpBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        steadystate->accept(v);
        (void)v;
        /// use -> for pointer member
        jacobian_block->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->conserve) {
            item->accept(v);
        }
        (void)v;
    }
 
    void MatexpBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        steadystate->accept(v);
        (void)v;
        /// use -> for pointer member
        jacobian_block->accept(v);
        (void)v;
        /// visit each element of vector
        for (auto& item : this->conserve) {
            item->accept(v);
        }
        (void)v;
    }
 
    void MatexpBlock::accept(visitor::Visitor& v) {
        v.visit_matexp_block(*this);
    }
 
    void MatexpBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_matexp_block(*this);
    }
 
 
    MatexpBlock::MatexpBlock(Boolean* steadystate, StatementBlock* jacobian_block, const ConserveVector& conserve)
                : steadystate(steadystate), jacobian_block(jacobian_block), conserve(conserve) { set_parent_in_children(); }
 
 
        MatexpBlock::MatexpBlock(std::shared_ptr<Boolean> steadystate, std::shared_ptr<StatementBlock> jacobian_block, const ConserveVector& conserve)
                : steadystate(steadystate), jacobian_block(jacobian_block), conserve(conserve) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    MatexpBlock::MatexpBlock(const MatexpBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.steadystate) {
                this->steadystate.reset(obj.steadystate->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.jacobian_block) {
                this->jacobian_block.reset(obj.jacobian_block->clone());
            }
            /// copy each element of vector
            for (auto& item : obj.conserve) {
                this->conserve.emplace_back(item->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void MatexpBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (steadystate) {
                steadystate->set_parent(this);
            }
            /// optional member could be nullptr
            if (jacobian_block) {
                jacobian_block->set_parent(this);
            }
            /// set parent for each element of the vector
            for (auto& item : conserve) {
                    item->set_parent(this);
 
            }
 
    }
 
 
    
                       void MatexpBlock::set_steadystate(std::shared_ptr<Boolean>&& steadystate) {
                           this->steadystate = steadystate;
                           // set parents
                           if (steadystate) {
                               steadystate->set_parent(this);
                           }
                       }
 
                       void MatexpBlock::set_steadystate(const std::shared_ptr<Boolean>& steadystate) {
                           this->steadystate = steadystate;
                           // set parents
                           if (steadystate) {
                               steadystate->set_parent(this);
                           }
                       }
                    
    
                       void MatexpBlock::set_jacobian_block(std::shared_ptr<StatementBlock>&& jacobian_block) {
                           this->jacobian_block = jacobian_block;
                           // set parents
                           if (jacobian_block) {
                               jacobian_block->set_parent(this);
                           }
                       }
 
                       void MatexpBlock::set_jacobian_block(const std::shared_ptr<StatementBlock>& jacobian_block) {
                           this->jacobian_block = jacobian_block;
                           // set parents
                           if (jacobian_block) {
                               jacobian_block->set_parent(this);
                           }
                       }
                    
    
                       void MatexpBlock::set_conserve(ConserveVector&& conserve) {
                           this->conserve = conserve;
                           // set parents
                           for (auto& ii : conserve) {
                                   ii->set_parent(this);
                            }
                       }
 
                       void MatexpBlock::set_conserve(const ConserveVector& conserve) {
                           this->conserve = conserve;
                           // set parents
                           for (auto& ii : conserve) {
                                   ii->set_parent(this);
                            }
                       }
                    
 
 
    ///
    /// CvodeBlock member functions definition
    ///
 
      
 
      std::string CvodeBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
      
 
      
 
    void CvodeBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        n_odes->accept(v);
        (void)v;
        /// use -> for pointer member
        non_stiff_block->accept(v);
        (void)v;
        /// use -> for pointer member
        stiff_block->accept(v);
        (void)v;
    }
 
    void CvodeBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        n_odes->accept(v);
        (void)v;
        /// use -> for pointer member
        non_stiff_block->accept(v);
        (void)v;
        /// use -> for pointer member
        stiff_block->accept(v);
        (void)v;
    }
 
    void CvodeBlock::accept(visitor::Visitor& v) {
        v.visit_cvode_block(*this);
    }
 
    void CvodeBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_cvode_block(*this);
    }
 
 
    CvodeBlock::CvodeBlock(Name* name, Integer* n_odes, StatementBlock* non_stiff_block, StatementBlock* stiff_block)
                : name(name), n_odes(n_odes), non_stiff_block(non_stiff_block), stiff_block(stiff_block) { set_parent_in_children(); }
 
 
        CvodeBlock::CvodeBlock(std::shared_ptr<Name> name, std::shared_ptr<Integer> n_odes, std::shared_ptr<StatementBlock> non_stiff_block, std::shared_ptr<StatementBlock> stiff_block)
                : name(name), n_odes(n_odes), non_stiff_block(non_stiff_block), stiff_block(stiff_block) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    CvodeBlock::CvodeBlock(const CvodeBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.n_odes) {
                this->n_odes.reset(obj.n_odes->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.non_stiff_block) {
                this->non_stiff_block.reset(obj.non_stiff_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.stiff_block) {
                this->stiff_block.reset(obj.stiff_block->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void CvodeBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (n_odes) {
                n_odes->set_parent(this);
            }
            /// optional member could be nullptr
            if (non_stiff_block) {
                non_stiff_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (stiff_block) {
                stiff_block->set_parent(this);
            }
 
    }
 
 
    
                       void CvodeBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void CvodeBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void CvodeBlock::set_n_odes(std::shared_ptr<Integer>&& n_odes) {
                           this->n_odes = n_odes;
                           // set parents
                           if (n_odes) {
                               n_odes->set_parent(this);
                           }
                       }
 
                       void CvodeBlock::set_n_odes(const std::shared_ptr<Integer>& n_odes) {
                           this->n_odes = n_odes;
                           // set parents
                           if (n_odes) {
                               n_odes->set_parent(this);
                           }
                       }
                    
    
                       void CvodeBlock::set_non_stiff_block(std::shared_ptr<StatementBlock>&& non_stiff_block) {
                           this->non_stiff_block = non_stiff_block;
                           // set parents
                           if (non_stiff_block) {
                               non_stiff_block->set_parent(this);
                           }
                       }
 
                       void CvodeBlock::set_non_stiff_block(const std::shared_ptr<StatementBlock>& non_stiff_block) {
                           this->non_stiff_block = non_stiff_block;
                           // set parents
                           if (non_stiff_block) {
                               non_stiff_block->set_parent(this);
                           }
                       }
                    
    
                       void CvodeBlock::set_stiff_block(std::shared_ptr<StatementBlock>&& stiff_block) {
                           this->stiff_block = stiff_block;
                           // set parents
                           if (stiff_block) {
                               stiff_block->set_parent(this);
                           }
                       }
 
                       void CvodeBlock::set_stiff_block(const std::shared_ptr<StatementBlock>& stiff_block) {
                           this->stiff_block = stiff_block;
                           // set parents
                           if (stiff_block) {
                               stiff_block->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// LongitudinalDiffusionBlock member functions definition
    ///
 
      
 
      std::string LongitudinalDiffusionBlock::get_node_name() const {
                             return name->get_node_name();
                         }
      
 
      
      
 
      
 
    void LongitudinalDiffusionBlock::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        longitudinal_diffusion_statements->accept(v);
        (void)v;
        /// use -> for pointer member
        compartment_statements->accept(v);
        (void)v;
    }
 
    void LongitudinalDiffusionBlock::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        name->accept(v);
        (void)v;
        /// use -> for pointer member
        longitudinal_diffusion_statements->accept(v);
        (void)v;
        /// use -> for pointer member
        compartment_statements->accept(v);
        (void)v;
    }
 
    void LongitudinalDiffusionBlock::accept(visitor::Visitor& v) {
        v.visit_longitudinal_diffusion_block(*this);
    }
 
    void LongitudinalDiffusionBlock::accept(visitor::ConstVisitor& v) const {
        v.visit_longitudinal_diffusion_block(*this);
    }
 
 
    LongitudinalDiffusionBlock::LongitudinalDiffusionBlock(Name* name, StatementBlock* longitudinal_diffusion_statements, StatementBlock* compartment_statements)
                : name(name), longitudinal_diffusion_statements(longitudinal_diffusion_statements), compartment_statements(compartment_statements) { set_parent_in_children(); }
 
 
        LongitudinalDiffusionBlock::LongitudinalDiffusionBlock(std::shared_ptr<Name> name, std::shared_ptr<StatementBlock> longitudinal_diffusion_statements, std::shared_ptr<StatementBlock> compartment_statements)
                : name(name), longitudinal_diffusion_statements(longitudinal_diffusion_statements), compartment_statements(compartment_statements) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    LongitudinalDiffusionBlock::LongitudinalDiffusionBlock(const LongitudinalDiffusionBlock& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.name) {
                this->name.reset(obj.name->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.longitudinal_diffusion_statements) {
                this->longitudinal_diffusion_statements.reset(obj.longitudinal_diffusion_statements->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.compartment_statements) {
                this->compartment_statements.reset(obj.compartment_statements->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void LongitudinalDiffusionBlock::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (name) {
                name->set_parent(this);
            }
            /// optional member could be nullptr
            if (longitudinal_diffusion_statements) {
                longitudinal_diffusion_statements->set_parent(this);
            }
            /// optional member could be nullptr
            if (compartment_statements) {
                compartment_statements->set_parent(this);
            }
 
    }
 
 
    
                       void LongitudinalDiffusionBlock::set_name(std::shared_ptr<Name>&& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
 
                       void LongitudinalDiffusionBlock::set_name(const std::shared_ptr<Name>& name) {
                           this->name = name;
                           // set parents
                           if (name) {
                               name->set_parent(this);
                           }
                       }
                    
    
                       void LongitudinalDiffusionBlock::set_longitudinal_diffusion_statements(std::shared_ptr<StatementBlock>&& longitudinal_diffusion_statements) {
                           this->longitudinal_diffusion_statements = longitudinal_diffusion_statements;
                           // set parents
                           if (longitudinal_diffusion_statements) {
                               longitudinal_diffusion_statements->set_parent(this);
                           }
                       }
 
                       void LongitudinalDiffusionBlock::set_longitudinal_diffusion_statements(const std::shared_ptr<StatementBlock>& longitudinal_diffusion_statements) {
                           this->longitudinal_diffusion_statements = longitudinal_diffusion_statements;
                           // set parents
                           if (longitudinal_diffusion_statements) {
                               longitudinal_diffusion_statements->set_parent(this);
                           }
                       }
                    
    
                       void LongitudinalDiffusionBlock::set_compartment_statements(std::shared_ptr<StatementBlock>&& compartment_statements) {
                           this->compartment_statements = compartment_statements;
                           // set parents
                           if (compartment_statements) {
                               compartment_statements->set_parent(this);
                           }
                       }
 
                       void LongitudinalDiffusionBlock::set_compartment_statements(const std::shared_ptr<StatementBlock>& compartment_statements) {
                           this->compartment_statements = compartment_statements;
                           // set parents
                           if (compartment_statements) {
                               compartment_statements->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// WrappedExpression member functions definition
    ///
 
      
 
      
 
    void WrappedExpression::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void WrappedExpression::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        expression->accept(v);
        (void)v;
    }
 
    void WrappedExpression::accept(visitor::Visitor& v) {
        v.visit_wrapped_expression(*this);
    }
 
    void WrappedExpression::accept(visitor::ConstVisitor& v) const {
        v.visit_wrapped_expression(*this);
    }
 
 
    WrappedExpression::WrappedExpression(Expression* expression)
                : expression(expression) { set_parent_in_children(); }
 
 
        WrappedExpression::WrappedExpression(std::shared_ptr<Expression> expression)
                : expression(expression) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    WrappedExpression::WrappedExpression(const WrappedExpression& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.expression) {
                this->expression.reset(obj.expression->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void WrappedExpression::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (expression) {
                expression->set_parent(this);
            }
 
    }
 
 
    
                       void WrappedExpression::set_expression(std::shared_ptr<Expression>&& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
 
                       void WrappedExpression::set_expression(const std::shared_ptr<Expression>& expression) {
                           this->expression = expression;
                           // set parents
                           if (expression) {
                               expression->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// DerivimplicitCallback member functions definition
    ///
 
      
 
      
 
    void DerivimplicitCallback::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        node_to_solve->accept(v);
        (void)v;
    }
 
    void DerivimplicitCallback::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        node_to_solve->accept(v);
        (void)v;
    }
 
    void DerivimplicitCallback::accept(visitor::Visitor& v) {
        v.visit_derivimplicit_callback(*this);
    }
 
    void DerivimplicitCallback::accept(visitor::ConstVisitor& v) const {
        v.visit_derivimplicit_callback(*this);
    }
 
 
    DerivimplicitCallback::DerivimplicitCallback(Block* node_to_solve)
                : node_to_solve(node_to_solve) { set_parent_in_children(); }
 
 
        DerivimplicitCallback::DerivimplicitCallback(std::shared_ptr<Block> node_to_solve)
                : node_to_solve(node_to_solve) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    DerivimplicitCallback::DerivimplicitCallback(const DerivimplicitCallback& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.node_to_solve) {
                this->node_to_solve.reset(obj.node_to_solve->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void DerivimplicitCallback::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (node_to_solve) {
                node_to_solve->set_parent(this);
            }
 
    }
 
 
    
                       void DerivimplicitCallback::set_node_to_solve(std::shared_ptr<Block>&& node_to_solve) {
                           this->node_to_solve = node_to_solve;
                           // set parents
                           if (node_to_solve) {
                               node_to_solve->set_parent(this);
                           }
                       }
 
                       void DerivimplicitCallback::set_node_to_solve(const std::shared_ptr<Block>& node_to_solve) {
                           this->node_to_solve = node_to_solve;
                           // set parents
                           if (node_to_solve) {
                               node_to_solve->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// SolutionExpression member functions definition
    ///
 
      
 
      
      
 
      
 
    void SolutionExpression::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        solve_block->accept(v);
        (void)v;
        /// use -> for pointer member
        node_to_solve->accept(v);
        (void)v;
    }
 
    void SolutionExpression::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        solve_block->accept(v);
        (void)v;
        /// use -> for pointer member
        node_to_solve->accept(v);
        (void)v;
    }
 
    void SolutionExpression::accept(visitor::Visitor& v) {
        v.visit_solution_expression(*this);
    }
 
    void SolutionExpression::accept(visitor::ConstVisitor& v) const {
        v.visit_solution_expression(*this);
    }
 
 
    SolutionExpression::SolutionExpression(SolveBlock* solve_block, Expression* node_to_solve)
                : solve_block(solve_block), node_to_solve(node_to_solve) { set_parent_in_children(); }
 
 
        SolutionExpression::SolutionExpression(std::shared_ptr<SolveBlock> solve_block, std::shared_ptr<Expression> node_to_solve)
                : solve_block(solve_block), node_to_solve(node_to_solve) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    SolutionExpression::SolutionExpression(const SolutionExpression& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.solve_block) {
                this->solve_block.reset(obj.solve_block->clone());
            }
            /// pointer member must be reseted with the new copy
            if (obj.node_to_solve) {
                this->node_to_solve.reset(obj.node_to_solve->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void SolutionExpression::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (solve_block) {
                solve_block->set_parent(this);
            }
            /// optional member could be nullptr
            if (node_to_solve) {
                node_to_solve->set_parent(this);
            }
 
    }
 
 
    
                       void SolutionExpression::set_solve_block(std::shared_ptr<SolveBlock>&& solve_block) {
                           this->solve_block = solve_block;
                           // set parents
                           if (solve_block) {
                               solve_block->set_parent(this);
                           }
                       }
 
                       void SolutionExpression::set_solve_block(const std::shared_ptr<SolveBlock>& solve_block) {
                           this->solve_block = solve_block;
                           // set parents
                           if (solve_block) {
                               solve_block->set_parent(this);
                           }
                       }
                    
    
                       void SolutionExpression::set_node_to_solve(std::shared_ptr<Expression>&& node_to_solve) {
                           this->node_to_solve = node_to_solve;
                           // set parents
                           if (node_to_solve) {
                               node_to_solve->set_parent(this);
                           }
                       }
 
                       void SolutionExpression::set_node_to_solve(const std::shared_ptr<Expression>& node_to_solve) {
                           this->node_to_solve = node_to_solve;
                           // set parents
                           if (node_to_solve) {
                               node_to_solve->set_parent(this);
                           }
                       }
                    
 
 
    ///
    /// UpdateDt member functions definition
    ///
 
      
 
      
 
    void UpdateDt::visit_children(visitor::Visitor& v) {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void UpdateDt::visit_children(visitor::ConstVisitor& v) const {
        /// use -> for pointer member
        value->accept(v);
        (void)v;
    }
 
    void UpdateDt::accept(visitor::Visitor& v) {
        v.visit_update_dt(*this);
    }
 
    void UpdateDt::accept(visitor::ConstVisitor& v) const {
        v.visit_update_dt(*this);
    }
 
 
    UpdateDt::UpdateDt(Double* value)
                : value(value) { set_parent_in_children(); }
 
 
        UpdateDt::UpdateDt(std::shared_ptr<Double> value)
                : value(value) { set_parent_in_children(); }
 
 
    /// copy constructor implementation
    UpdateDt::UpdateDt(const UpdateDt& obj) {
            /// pointer member must be reseted with the new copy
            if (obj.value) {
                this->value.reset(obj.value->clone());
            }
 
        /// if there is a token, make copy
        if (obj.token) {
            this-> token = std::shared_ptr<ModToken>(obj.token->clone());
        }
 
        /// set parents
        set_parent_in_children();
    }
 
 
    /// set this parent in the children
    void UpdateDt::set_parent_in_children() {
 
            /// optional member could be nullptr
            if (value) {
                value->set_parent(this);
            }
 
    }
 
 
    
                       void UpdateDt::set_value(std::shared_ptr<Double>&& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
 
                       void UpdateDt::set_value(const std::shared_ptr<Double>& value) {
                           this->value = value;
                           // set parents
                           if (value) {
                               value->set_parent(this);
                           }
                       }
                    
 
}  // namespace nmodl::ast