Creating C++ Libraries (for ament_cmake)

The C++ library block for ament_cmake

The base package can be created with

cd ~/ros2_tutorial_workspace/src
ros2 pkg create cpp_package_with_a_library \
--build-type ament_cmake \
--dependencies rclcpp

resulting in the following output

Package-related sources

In this step, we’ll work on these.

cpp_package_with_a_library
├── CMakeLists.txt
├── include
│   └── cpp_package_with_a_library
│       └── sample_class.hpp
├── package.xml
└── src
    ├── sample_class.cpp
    ├── sample_class_local_node.cpp
    ├── sample_class_local_node.hpp
    └── sample_class_local_node_main.cpp

The files already exist, we just need to modify them as follows

package.xml

Nothing new here.

package.xml

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>cpp_package_with_a_library</name>
  <version>0.0.0</version>
  <description>TODO: Package description</description>
  <maintainer email="murilomarinho@ieee.org">murilo</maintainer>
  <license>TODO: License declaration</license>

  <buildtool_depend>ament_cmake</buildtool_depend>

  <depend>rclcpp</depend>

  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

CMakeLists.txt

A one-size-fits-most solution is shown below. We don’t need to add multiple libraries, so a single library can hold all the content you might want to export. The user of the library will see it nicely split by your header files, so it will be as neat as you make them.

Note that, because the local Node depends on the library being exported by this project, it needs to explicitly link to it.

CMakeLists.txt

cmake_minimum_required(VERSION 3.8)
project(cpp_package_with_a_library)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# find dependencies
find_package(ament_cmake REQUIRED)
find_package(rclcpp REQUIRED)
find_package(Eigen3 REQUIRED)
find_package(Qt5Core REQUIRED)

####################################
# CPP Shared Library Block [BEGIN] #
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv #
# https://ros2-tutorial.readthedocs.io/en/latest/
# The most common use case is to merge everything you need to export
# into the same shared library called ${PROJECT_NAME}.
add_library(${PROJECT_NAME} SHARED
    src/sample_class.cpp

    )

ament_target_dependencies(${PROJECT_NAME}
    rclcpp

    )

target_include_directories(${PROJECT_NAME}
    PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>)

ament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)
ament_export_dependencies(
    rclcpp
    Eigen3
    Qt5Core

    )

target_link_libraries(${PROJECT_NAME}
    Qt5::Core

    )

install(
    DIRECTORY include/
    DESTINATION include
    )

install(
    TARGETS ${PROJECT_NAME}
    EXPORT export_${PROJECT_NAME}
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
    RUNTIME DESTINATION bin
    INCLUDES DESTINATION include
    )
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #
# CPP Shared Library Block [END] #
##################################

############################
# CPP Binary Block [BEGIN] #
# vvvvvvvvvvvvvvvvvvvvvvvv #
# https://ros2-tutorial.readthedocs.io/en/latest/
# While we cant use blocks https://cmake.org/cmake/help/latest/command/block.html#command:block
# we use set--unset
set(RCLCPP_LOCAL_BINARY_NAME sample_class_local_node)

add_executable(${RCLCPP_LOCAL_BINARY_NAME}
    src/sample_class_local_node_main.cpp
    src/sample_class_local_node.cpp
    src/sample_class.cpp

    )

ament_target_dependencies(${RCLCPP_LOCAL_BINARY_NAME}
    rclcpp

    )

target_link_libraries(${RCLCPP_LOCAL_BINARY_NAME}
    ${PROJECT_NAME}

    )

target_include_directories(${RCLCPP_LOCAL_BINARY_NAME} PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>)

target_compile_features(${RCLCPP_LOCAL_BINARY_NAME} PUBLIC c_std_99 cxx_std_17)

install(TARGETS ${RCLCPP_LOCAL_BINARY_NAME}
    DESTINATION lib/${PROJECT_NAME})

unset(RCLCPP_LOCAL_BINARY_NAME)
# ^^^^^^^^^^^^^^^^^^^^^^ #
# CPP Binary Block [END] #
##########################

if(BUILD_TESTING)
    find_package(ament_lint_auto REQUIRED)
    # the following line skips the linter which checks for copyrights
    # comment the line when a copyright and license is added to all source files
    set(ament_cmake_copyright_FOUND TRUE)
    # the following line skips cpplint (only works in a git repo)
    # comment the line when this package is in a git repo and when
    # a copyright and license is added to all source files
    set(ament_cmake_cpplint_FOUND TRUE)
    ament_lint_auto_find_test_dependencies()
endif()

ament_package()

Library sources

In this step, we’ll work on these.

cpp_package_with_a_library
├── CMakeLists.txt
├── include
│   └── cpp_package_with_a_library
│       └── sample_class.hpp
├── package.xml
└── src
    ├── sample_class.cpp
    ├── sample_class_local_node.cpp
    ├── sample_class_local_node.hpp
    └── sample_class_local_node_main.cpp

sample_class.hpp

A class that does a bunch of nothing, but that depends on Eigen3 and Qt, as an example.

sample_class.hpp

#pragma once

#include <ostream>

#include <QString>
#include <eigen3/Eigen/Dense>

class SampleClass
{
private:
    int a_private_member_;
    const QString a_private_qt_string_;
    const Eigen::MatrixXd a_private_eigen3_matrix_;

public:
    SampleClass();

    int get_a_private_member() const;
    void set_a_private_member(int value);
    std::string to_string() const;

    static double sum_of_squares(const double&a, const double& b);
};

std::ostream& operator<<(std::ostream& os, const SampleClass& sc);

sample_class.cpp

sample_class.cpp

#include <cpp_package_with_a_library/sample_class.hpp>



/**
 * @brief SampleClass::SampleClass the default constructor.
 */
SampleClass::SampleClass():
    a_private_qt_string_("I am a QString"),
    a_private_eigen3_matrix_((Eigen::Matrix2d() << 1,2,3,4).finished())
{

}

/**
 * @brief SampleClass::get_a_private_member.
 * @return an int with the value of a_private_member_.
 */
int SampleClass::get_a_private_member() const
{
    return a_private_member_;
}

/**
 * @brief SampleClass::set_a_private_member.
 * @param value The new value for a_private_member_.
 */
void SampleClass::set_a_private_member(int value)
{
    a_private_member_ = value;
}

/**
 * @brief SampleClass::sum_of_squares.
 * @param a The first number.
 * @param b The second number.
 * @return a*a + 2*a*b + b*b.
 */
double SampleClass::sum_of_squares(const double &a, const double &b)
{
    return a*a + 2*a*b + b*b;
}

/**
 * @brief SampleClass::to_string converts a SampleClass to a std::string representation.
 * @return a pretty(-ish) std::string representation of the object.
 */
std::string SampleClass::to_string() const
{
    std::stringstream ss;
    ss << "Sample_Class:: " << std::endl <<
          "a_private_member_ = "        << std::to_string(a_private_member_) << std::endl <<
          "a_private_qt_string_ = "     << a_private_qt_string_.toStdString() << std::endl <<
          "a_private_eigen3_matrix_ = " << a_private_eigen3_matrix_ << std::endl;
    return ss.str();
}

/**
 * @brief operator << the stream operator for SampleClass objects.
 * @param [in/out] the std::ostream to be modified.
 * @param [in] sc the SampleClass whose representation is to be streamed.
 * @return the modified os with the added SampleClass string representation.
 * @see SampleClass::to_string().
 */
std::ostream &operator<<(std::ostream &os, const SampleClass &sc)
{
    return os << sc.to_string();
}

Sources for a local node that uses the library

In this step, we’ll work on these.

cpp_package_with_a_library
├── CMakeLists.txt
├── include
│   └── cpp_package_with_a_library
│       └── sample_class.hpp
├── package.xml
└── src
    ├── sample_class.cpp
    ├── sample_class_local_node.cpp
    ├── sample_class_local_node.hpp
    └── sample_class_local_node_main.cpp

Just in case you need to have a node, in the same package, that also uses the library exported by this package. Nothing too far from what we have already done.

sample_class_local_node.cpp

sample_class.cpp

#include "sample_class_local_node.hpp"

/**
 * @brief SampleClassLocalNode::SampleClassLocalNode Default constructor.
 */
SampleClassLocalNode::SampleClassLocalNode():
    rclcpp::Node("sample_class_local_node"),
    timer_period_(0.5),
    print_count_(0)
{
    timer_ = create_wall_timer(
                std::chrono::milliseconds(long(timer_period_*1e3)),
                std::bind(&SampleClassLocalNode::_timer_callback, this)
                );
}

/**
 * @brief SampleClassLocalNode::_timer_callback periodically prints class info using RCLCPP_INFO.
 */
void SampleClassLocalNode::_timer_callback()
{
    RCLCPP_INFO_STREAM(get_logger(),
                       std::string("sum_of_squares = ") +
                       std::to_string(SampleClass::sum_of_squares(print_count_,print_count_-5))
                       );

    RCLCPP_INFO_STREAM(get_logger(),
                       sample_class_.to_string() +
                       std::to_string(print_count_) +
                       std::string(" times.")
                       );
    print_count_++;
}

sample_class_local_node.hpp

sample_class_local_node.cpp

#pragma once

#include <rclcpp/rclcpp.hpp>
#include <cpp_package_with_a_library/sample_class.hpp>

/**
 * @brief A ROS2 Node that uses the SampleClass within the same package.
 */
class SampleClassLocalNode: public rclcpp::Node
{
private:
    SampleClass sample_class_;

    double timer_period_;
    int print_count_;
    rclcpp::TimerBase::SharedPtr timer_;

    void _timer_callback();
public:
    SampleClassLocalNode();

};

sample_class_local_node_main.cpp

sample_class.cpp

#include <rclcpp/rclcpp.hpp>

#include "sample_class_local_node.hpp"

int main(int argc, char** argv)
{
    rclcpp::init(argc,argv);

    try
    {
        auto node = std::make_shared<SampleClassLocalNode>();

        rclcpp::spin(node);
    }
    catch (const std::exception& e)
    {
        std::cerr << std::string("::Exception::") << e.what();
    }

    return 0;
}