#include "rclcpp/node_options.hpp"

#include <limits>

#include <memory>

#include <string>

#include <vector>

#include <utility>

#include "rclcpp/detail/utilities.hpp"

#include "rclcpp/exceptions.hpp"

#include "rclcpp/logging.hpp"

#include "rclcpp/publisher_options.hpp"

#include "rclcpp/qos.hpp"

using rclcpp::exceptions::throw_from_rcl_error;

namespace rclcpp

{

namespace detail

{

rcl_node_options_t_destructor(rcl_node_options_t * node_options)

}

} // namespace detail

NodeOptions::NodeOptions(rcl_allocator_t allocator)

: node_options_(nullptr, detail::rcl_node_options_t_destructor), allocator_(allocator)

{}

NodeOptions::NodeOptions(const NodeOptions & other)

}

NodeOptions &

NodeOptions::operator=(const NodeOptions & other)

{

if (this != &other) {

this->node_options_.reset();

this->context_ = other.context_;

this->arguments_ = other.arguments_;

this->parameter_overrides_ = other.parameter_overrides_;

this->use_global_arguments_ = other.use_global_arguments_;

this->enable_rosout_ = other.enable_rosout_;

this->use_intra_process_comms_ = other.use_intra_process_comms_;

this->enable_topic_statistics_ = other.enable_topic_statistics_;

this->start_parameter_services_ = other.start_parameter_services_;

this->start_parameter_event_publisher_ = other.start_parameter_event_publisher_;

this->clock_type_ = other.clock_type_;

this->clock_qos_ = other.clock_qos_;

this->use_clock_thread_ = other.use_clock_thread_;

this->enable_logger_service_ = other.enable_logger_service_;

this->parameter_event_qos_ = other.parameter_event_qos_;

this->rosout_qos_ = other.rosout_qos_;

this->parameter_event_publisher_options_ = other.parameter_event_publisher_options_;

this->allow_undeclared_parameters_ = other.allow_undeclared_parameters_;

this->automatically_declare_parameters_from_overrides_ =

other.automatically_declare_parameters_from_overrides_;

this->allocator_ = other.allocator_;

}

return *this;

}

const rcl_node_options_t *

NodeOptions::get_rcl_node_options() const

{

// If it is nullptr, create it on demand.

if (!node_options_) {

node_options_.reset(new rcl_node_options_t);

*node_options_ = rcl_node_get_default_options();

node_options_->allocator = this->allocator_;

node_options_->use_global_arguments = this->use_global_arguments_;

node_options_->enable_rosout = this->enable_rosout_;

node_options_->rosout_qos = this->rosout_qos_.get_rmw_qos_profile();

int c_argc = 0;

std::unique_ptr<const char *[]> c_argv;

if (!this->arguments_.empty()) {

if (this->arguments_.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {

throw_from_rcl_error(RCL_RET_INVALID_ARGUMENT, "Too many args");

}

c_argc = static_cast<int>(this->arguments_.size());

c_argv.reset(new const char *[c_argc]);

for (std::size_t i = 0; i < this->arguments_.size(); ++i) {

c_argv[i] = this->arguments_[i].c_str();

}

}

rcl_ret_t ret = rcl_parse_arguments(

c_argc, c_argv.get(), this->allocator_, &(node_options_->arguments));

if (RCL_RET_OK != ret) {

throw_from_rcl_error(ret, "failed to parse arguments");

}

std::vector<std::string> unparsed_ros_arguments = detail::get_unparsed_ros_arguments(

c_argc, c_argv.get(), &(node_options_->arguments), this->allocator_);

if (!unparsed_ros_arguments.empty()) {

throw exceptions::UnknownROSArgsError(std::move(unparsed_ros_arguments));

}

}

return node_options_.get();

}

rclcpp::Context::SharedPtr

NodeOptions::context() const

{

return this->context_;

}

NodeOptions &

NodeOptions::context(rclcpp::Context::SharedPtr context)

{

this->context_ = context;

return *this;

}

const std::vector<std::string> &

NodeOptions::arguments() const

{

return this->arguments_;

}

NodeOptions &

NodeOptions::arguments(const std::vector<std::string> & arguments)

{

this->node_options_.reset(); // reset node options to make it be recreated on next access.

this->arguments_ = arguments;

return *this;

}

std::vector<rclcpp::Parameter> &

NodeOptions::parameter_overrides()

{

return this->parameter_overrides_;

}

const std::vector<rclcpp::Parameter> &

NodeOptions::parameter_overrides() const

{

return this->parameter_overrides_;

}

NodeOptions &

NodeOptions::parameter_overrides(const std::vector<rclcpp::Parameter> & parameter_overrides)

{

this->parameter_overrides_ = parameter_overrides;

return *this;

}

NodeOptions::use_global_arguments() const

{

return this->use_global_arguments_;

}

NodeOptions &

NodeOptions::use_global_arguments(bool use_global_arguments)

{

this->node_options_.reset(); // reset node options to make it be recreated on next access.

this->use_global_arguments_ = use_global_arguments;

return *this;

}

NodeOptions::enable_rosout() const

{

return this->enable_rosout_;

}

NodeOptions &

NodeOptions::enable_rosout(bool enable_rosout)

{

this->node_options_.reset(); // reset node options to make it be recreated on next access.

this->enable_rosout_ = enable_rosout;

return *this;

}

NodeOptions::use_intra_process_comms() const

{

return this->use_intra_process_comms_;

}

NodeOptions &

NodeOptions::use_intra_process_comms(bool use_intra_process_comms)

{

this->use_intra_process_comms_ = use_intra_process_comms;

return *this;

}

NodeOptions::enable_topic_statistics() const

{

return this->enable_topic_statistics_;

}

NodeOptions &

NodeOptions::enable_topic_statistics(bool enable_topic_statistics)

{

this->enable_topic_statistics_ = enable_topic_statistics;

return *this;

}

NodeOptions::start_parameter_services() const

{

return this->start_parameter_services_;

}

NodeOptions &

NodeOptions::start_parameter_services(bool start_parameter_services)

{

this->start_parameter_services_ = start_parameter_services;

return *this;

}

NodeOptions::enable_logger_service() const

{

return this->enable_logger_service_;

}

NodeOptions &

NodeOptions::enable_logger_service(bool enable_logger_service)

{

this->enable_logger_service_ = enable_logger_service;

return *this;

}

NodeOptions::start_parameter_event_publisher() const

{

return this->start_parameter_event_publisher_;

}

NodeOptions &

NodeOptions::start_parameter_event_publisher(bool start_parameter_event_publisher)

{

this->start_parameter_event_publisher_ = start_parameter_event_publisher;

return *this;

}

const rcl_clock_type_t &

NodeOptions::clock_type() const

{

return this->clock_type_;

}

NodeOptions &

NodeOptions::clock_type(const rcl_clock_type_t & clock_type)

{

this->clock_type_ = clock_type;

return *this;

}

const rclcpp::QoS &

NodeOptions::clock_qos() const

{

return this->clock_qos_;

}

NodeOptions &

NodeOptions::clock_qos(const rclcpp::QoS & clock_qos)

{

this->clock_qos_ = clock_qos;

return *this;

}

NodeOptions::use_clock_thread() const

{

return this->use_clock_thread_;

}

NodeOptions &

NodeOptions::use_clock_thread(bool use_clock_thread)

{

this->use_clock_thread_ = use_clock_thread;

return *this;

}

const rclcpp::QoS &

NodeOptions::parameter_event_qos() const

{

return this->parameter_event_qos_;

}

NodeOptions &

NodeOptions::parameter_event_qos(const rclcpp::QoS & parameter_event_qos)

{

this->parameter_event_qos_ = parameter_event_qos;

return *this;

}

const rclcpp::QoS &

NodeOptions::rosout_qos() const

{

return this->rosout_qos_;

}

NodeOptions &

NodeOptions::rosout_qos(const rclcpp::QoS & rosout_qos)

{

this->node_options_.reset();

this->rosout_qos_ = rosout_qos;

return *this;

}

const rclcpp::PublisherOptionsBase &

NodeOptions::parameter_event_publisher_options() const

{

return parameter_event_publisher_options_;

}

NodeOptions &

NodeOptions::parameter_event_publisher_options(

const rclcpp::PublisherOptionsBase & parameter_event_publisher_options)

{

parameter_event_publisher_options_ = parameter_event_publisher_options;

return *this;

}

NodeOptions::allow_undeclared_parameters() const

{

return this->allow_undeclared_parameters_;

}

NodeOptions &

NodeOptions::allow_undeclared_parameters(bool allow_undeclared_parameters)

{

this->allow_undeclared_parameters_ = allow_undeclared_parameters;

return *this;

}

NodeOptions::automatically_declare_parameters_from_overrides() const

{

return this->automatically_declare_parameters_from_overrides_;

}

NodeOptions &

NodeOptions::automatically_declare_parameters_from_overrides(

bool automatically_declare_parameters_from_overrides)

{

this->automatically_declare_parameters_from_overrides_ =

automatically_declare_parameters_from_overrides;

return *this;

}

const rcl_allocator_t &

NodeOptions::allocator() const

{

return this->allocator_;

}

NodeOptions &

NodeOptions::allocator(rcl_allocator_t allocator)

{

this->node_options_.reset(); // reset node options to make it be recreated on next access.

this->allocator_ = allocator;

return *this;

}

} // namespace rclcpp