plugin_base_node.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2022 LEIDOS.
 *
 * 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.
 */
 
#pragma once
 
#include <gtest/gtest_prod.h>
#include <rclcpp/rclcpp.hpp>
#include <carma_planning_msgs/msg/plugin.hpp>
#include <carma_wm/WMListener.hpp>
#include <carma_wm/WorldModel.hpp>
 
#include <carma_ros2_utils/carma_lifecycle_node.hpp>
 
namespace carma_guidance_plugins
{
 
  class PluginBaseNode : public carma_ros2_utils::CarmaLifecycleNode
  {
 
  private:
    // Publishers
    //immediately on node construction regardless of lifecycle state. This is meant to allow for fast plugin activation on startup.
    rclcpp::Publisher<carma_planning_msgs::msg::Plugin>::SharedPtr plugin_discovery_pub_;
 
    // Timers
    rclcpp::TimerBase::SharedPtr discovery_timer_;
 
    // WorldModel listener
    // This variable is intentionally private, so that is can be lazily initialized 
    // when the extending class calls get_world_model_listener(); or get_world_model();
    std::shared_ptr<carma_wm::WMListener> wm_listener_;
 
    // World Model populated by the listener at runtime
    // This variable is intentionally private, so that is can be lazily initialized 
    // when the extending class calls get_world_model_listener(); or get_world_model();
    carma_wm::WorldModelConstPtr wm_;
 
    void discovery_timer_callback();
 
    void lazy_wm_initialization();
 
  public:
    explicit PluginBaseNode(const rclcpp::NodeOptions &);
 
    virtual ~PluginBaseNode() = default;
 
    virtual std::shared_ptr<carma_wm::WMListener> get_world_model_listener() final;
 
    virtual carma_wm::WorldModelConstPtr get_world_model() final;
 
    virtual bool get_activation_status() final;
 
 
    virtual uint8_t get_type();
 
    std::string get_plugin_name_and_ns() const;
 
    std::string get_plugin_name() const;
 
    virtual bool get_availability() = 0;
 
    virtual std::string get_capability() = 0;
 
    virtual std::string get_version_id() = 0;
 
    virtual carma_ros2_utils::CallbackReturn on_configure_plugin() = 0;
 
    virtual carma_ros2_utils::CallbackReturn on_activate_plugin();
 
    virtual carma_ros2_utils::CallbackReturn on_deactivate_plugin();
 
    virtual carma_ros2_utils::CallbackReturn on_cleanup_plugin();
 
    virtual carma_ros2_utils::CallbackReturn on_shutdown_plugin();
 
    virtual carma_ros2_utils::CallbackReturn on_error_plugin(const std::string &exception_string);
 
    // Overrides
    // For simplicity of managing the plugin state machine all lifecycle callbacks are implemented as final by the core extending classes (strategic, tactical, control)
    // Plugins will use the plugin specific callbacks via the template pattern 
    carma_ros2_utils::CallbackReturn handle_on_configure(const rclcpp_lifecycle::State &) override;
    carma_ros2_utils::CallbackReturn handle_on_activate(const rclcpp_lifecycle::State &) override;
    carma_ros2_utils::CallbackReturn handle_on_deactivate(const rclcpp_lifecycle::State &) override;
    carma_ros2_utils::CallbackReturn handle_on_cleanup(const rclcpp_lifecycle::State &) override;
    carma_ros2_utils::CallbackReturn handle_on_shutdown(const rclcpp_lifecycle::State &) override; 
    carma_ros2_utils::CallbackReturn handle_on_error(const rclcpp_lifecycle::State &, const std::string &exception_string) override;
    
    // Unit Test Accessors
    FRIEND_TEST(carma_guidance_plugins_test, connections_test);
 
  };
 
} // carma_guidance_plugins