[21099] X-Types examples

examples/CMakeLists.txt

@@ -18,3 +18,4 @@ add_subdirectory(cpp/custom_payload_pool)
 add_subdirectory(cpp/dds)
 add_subdirectory(cpp/hello_world)
 add_subdirectory(cpp/rtps)
+add_subdirectory(cpp/xtypes)

examples/cpp/xtypes/Application.cpp

@@ -0,0 +1,62 @@
+// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file Application.cpp
+ *
+ */
+
+#include "Application.hpp"
+
+#include "CLIParser.hpp"
+#include "SubscriberApp.hpp"
+#include "PublisherApp.hpp"
+
+using namespace eprosima::fastdds::dds;
+
+namespace eprosima {
+namespace fastdds {
+namespace examples {
+namespace xtypes {
+
+//! Factory method to create a publisher or subscriber
+std::shared_ptr<Application> Application::make_app(
+ const CLIParser::config& config,
+ const std::string& topic_name)
+{
+ std::shared_ptr<Application> entity;
+ switch (config.entity)
+ {
+ case CLIParser::EntityKind::PUBLISHER:
+ {
+ entity = std::make_shared<PublisherApp>(config, topic_name);
+ break;
+ }
+ case CLIParser::EntityKind::SUBSCRIBER:
+ {
+ entity = std::make_shared<SubscriberApp>(config, topic_name);
+ break;
+ }
+ case CLIParser::EntityKind::UNDEFINED:
+ default:
+ throw std::runtime_error("Entity initialization failed");
+ break;
+ }
+ return entity;
+}
+
+} // namespace xtypes
+} // namespace examples
+} // namespace fastdds
+} // namespace eprosima

examples/cpp/xtypes/Application.hpp

@@ -0,0 +1,56 @@
+// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file Application.hpp
+ *
+ */
+
+#ifndef _FASTDDS_EXAMPLES_XTYPES_APPLICATION_HPP_
+#define _FASTDDS_EXAMPLES_XTYPES_APPLICATION_HPP_
+
+#include <atomic>
+
+#include "CLIParser.hpp"
+
+namespace eprosima {
+namespace fastdds {
+namespace examples {
+namespace xtypes {
+
+class Application
+{
+public:
+
+ //! Virtual destructor
+ virtual ~Application() = default;
+
+ //! Run application
+ virtual void run() = 0;
+
+ //! Trigger the end of execution
+ virtual void stop() = 0;
+
+ //! Factory method to create applications based on configuration
+ static std::shared_ptr<Application> make_app(
+ const CLIParser::config& config,
+ const std::string& topic_name);
+};
+
+} // namespace xtypes
+} // namespace examples
+} // namespace fastdds
+} // namespace eprosima
+
+#endif /* _FASTDDS_EXAMPLES_XTYPES_APPLICATION_HPP_ */

examples/cpp/xtypes/CLIParser.hpp

@@ -0,0 +1,225 @@
+// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <csignal>
+#include <cstdlib>
+#include <iostream>
+
+#include <fastdds/dds/log/Log.hpp>
+
+#ifndef _FASTDDS_EXAMPLES_XTYPES_CLI_PARSER_HPP_
+#define _FASTDDS_EXAMPLES_XTYPES_CLI_PARSER_HPP_
+
+namespace eprosima {
+namespace fastdds {
+namespace examples {
+namespace xtypes {
+
+class CLIParser
+{
+public:
+
+ CLIParser() = delete;
+
+ //! Entity kind enumeration
+ enum class EntityKind : uint8_t
+ {
+ PUBLISHER,
+ SUBSCRIBER,
+ UNDEFINED
+ };
+
+ //! Configuration structure for the application
+ struct config
+ {
+ CLIParser::EntityKind entity = CLIParser::EntityKind::UNDEFINED;
+ uint16_t samples = 0;
+ };
+
+ /**
+ * @brief Print usage help message and exit with the given return code
+ *
+ * @param return_code return code to exit with
+ *
+ * @warning This method finishes the execution of the program with the input return code
+ */
+ static void print_help(
+ uint8_t return_code)
+ {
+ std::cout << "Usage: xtypes <entity> [options]" << std::endl;
+ std::cout << "" << std::endl;
+ std::cout << "Entities:" << std::endl;
+ std::cout << " publisher Run a publisher entity" << std::endl;
+ std::cout << " subscriber Run a subscriber entity" << std::endl;
+ std::cout << "" << std::endl;
+ std::cout << "Common options:" << std::endl;
+ std::cout << " -h, --help Print this help message" << std::endl;
+ std::cout << " -s <num>, --samples <num> Number of samples to send or receive" << std::endl;
+ std::cout << " [0 <= <num> <= 65535]" << std::endl;
+ std::cout << " (Default: 0 [unlimited])" << std::endl;
+ std::exit(return_code);
+ }
+
+ /**
+ * @brief Parse the command line options and return the configuration_config object
+ *
+ * @param argc number of arguments
+ * @param argv array of arguments
+ * @return configuration_config object with the parsed options
+ *
+ * @warning This method finishes the execution of the program if the input arguments are invalid
+ */
+ static config parse_cli_options(
+ int argc,
+ char* argv[])
+ {
+ config config;
+
+ if (argc < 2)
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "missing entity argument");
+ print_help(EXIT_FAILURE);
+ }
+
+ std::string first_argument = argv[1];
+
+ if (first_argument == "publisher" )
+ {
+ config.entity = CLIParser::EntityKind::PUBLISHER;
+ }
+ else if (first_argument == "subscriber")
+ {
+ config.entity = CLIParser::EntityKind::SUBSCRIBER;
+ }
+ else if (first_argument == "-h" || first_argument == "--help")
+ {
+ print_help(EXIT_SUCCESS);
+ }
+ else
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "parsing entity argument " + first_argument);
+ print_help(EXIT_FAILURE);
+ }
+
+ for (int i = 2; i < argc; ++i)
+ {
+ std::string arg = argv[i];
+ if (arg == "-h" || arg == "--help")
+ {
+ print_help(EXIT_SUCCESS);
+ }
+ else if (arg == "-s" || arg == "--samples")
+ {
+ if (i + 1 < argc)
+ {
+ try
+ {
+ int input = std::stoi(argv[++i]);
+ if (input < std::numeric_limits<std::uint16_t>::min() ||
+ input > std::numeric_limits<std::uint16_t>::max())
+ {
+ throw std::out_of_range("sample argument out of range");
+ }
+ else
+ {
+ if (config.entity == CLIParser::EntityKind::UNDEFINED)
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "entity not specified for --sample argument");
+ print_help(EXIT_FAILURE);
+ }
+ config.samples = static_cast<uint16_t>(input);
+ }
+ }
+ catch (const std::invalid_argument& e)
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "invalid sample argument for " + arg + ": " + e.what());
+ print_help(EXIT_FAILURE);
+ }
+ catch (const std::out_of_range& e)
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "sample argument out of range for " + arg + ": " + e.what());
+ print_help(EXIT_FAILURE);
+ }
+ }
+ else
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "missing argument for " + arg);
+ print_help(EXIT_FAILURE);
+ }
+ }
+ else
+ {
+ EPROSIMA_LOG_ERROR(CLI_PARSER, "unknown option " + arg);
+ print_help(EXIT_FAILURE);
+ }
+ }
+
+ return config;
+ }
+
+ /**
+ * @brief Parse the signal number into the signal name
+ *
+ * @param signum signal number
+ * @return std::string signal name
+ */
+ static std::string parse_signal(
+ const int& signum)
+ {
+ switch (signum)
+ {
+ case SIGINT:
+ return "SIGINT";
+ case SIGTERM:
+ return "SIGTERM";
+#ifndef _WIN32
+ case SIGQUIT:
+ return "SIGQUIT";
+ case SIGHUP:
+ return "SIGHUP";
+#endif // _WIN32
+ default:
+ return "UNKNOWN SIGNAL";
+ }
+ }
+
+ /**
+ * @brief Parse the entity kind into std::string
+ *
+ * @param entity entity kind
+ * @return std::string entity kind
+ */
+ static std::string parse_entity_kind(
+ const EntityKind& entity)
+ {
+ switch (entity)
+ {
+ case EntityKind::PUBLISHER:
+ return "Publisher";
+ case EntityKind::SUBSCRIBER:
+ return "Subscriber";
+ case EntityKind::UNDEFINED:
+ default:
+ return "Undefined entity";
+ }
+ }
+
+};
+
+} // namespace xtypes
+} // namespace examples
+} // namespace fastdds
+} // namespace eprosima
+
+#endif // _FASTDDS_EXAMPLES_XTYPES_CLI_PARSER_HPP_