.. _program_listing_file_include_rosbag2_cpp_writer.hpp:

Program Listing for File writer.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_rosbag2_cpp_writer.hpp>` (``include/rosbag2_cpp/writer.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2018, Bosch Software Innovations GmbH.
   //
   // 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.
   
   #ifndef ROSBAG2_CPP__WRITER_HPP_
   #define ROSBAG2_CPP__WRITER_HPP_
   
   #include <memory>
   #include <mutex>
   #include <string>
   #include <unordered_map>
   #include <vector>
   
   #include "rclcpp/serialization.hpp"
   #include "rclcpp/serialized_message.hpp"
   #include "rclcpp/time.hpp"
   
   #include "rosbag2_cpp/bag_events.hpp"
   #include "rosbag2_cpp/converter_options.hpp"
   #include "rosbag2_cpp/visibility_control.hpp"
   #include "rosbag2_cpp/writers/sequential_writer.hpp"
   
   #include "rosbag2_storage/serialized_bag_message.hpp"
   #include "rosbag2_storage/storage_options.hpp"
   #include "rosbag2_storage/topic_metadata.hpp"
   
   // This is necessary because of using stl types here. It is completely safe, because
   // a) the member is not accessible from the outside
   // b) there are no inline functions.
   #ifdef _WIN32
   # pragma warning(push)
   # pragma warning(disable:4251)
   #endif
   
   namespace rosbag2_cpp
   {
   namespace writer_interfaces
   {
   class BaseWriterInterface;
   }  // namespace writer_interfaces
   
   class ROSBAG2_CPP_PUBLIC Writer
   {
   public:
     explicit Writer(
       std::unique_ptr<rosbag2_cpp::writer_interfaces::BaseWriterInterface> writer_impl =
       std::make_unique<writers::SequentialWriter>());
   
     ~Writer();
   
     void open(const std::string & uri);
   
     void open(
       const rosbag2_storage::StorageOptions & storage_options,
       const ConverterOptions & converter_options = ConverterOptions());
   
     void close();
   
     void create_topic(const rosbag2_storage::TopicMetadata & topic_with_type);
   
     void create_topic(
       const rosbag2_storage::TopicMetadata & topic_with_type,
       const rosbag2_storage::MessageDefinition & message_definition);
   
     bool take_snapshot();
   
     void split_bagfile();
   
     void remove_topic(const rosbag2_storage::TopicMetadata & topic_with_type);
   
     void write(std::shared_ptr<const rosbag2_storage::SerializedBagMessage> message);
   
     void write(
       std::shared_ptr<const rosbag2_storage::SerializedBagMessage> message,
       const std::string & topic_name,
       const std::string & type_name,
       const std::string & serialization_format = "cdr");
   
     void write(
       std::shared_ptr<const rclcpp::SerializedMessage> message,
       const std::string & topic_name,
       const std::string & type_name,
       const rclcpp::Time & time,
       uint32_t sequence_number = 0);
   
     void write(
       std::shared_ptr<const rclcpp::SerializedMessage> message,
       const std::string & topic_name,
       const std::string & type_name,
       const rcutils_time_point_value_t & recv_timestamp,
       const rcutils_time_point_value_t & send_timestamp,
       uint32_t sequence_number = 0);
   
     template<class MessageT>
     void write(
       const MessageT & message,
       const std::string & topic_name,
       const rclcpp::Time & time,
       uint32_t sequence_number = 0)
     {
       auto serialized_msg = std::make_shared<rclcpp::SerializedMessage>();
   
       rclcpp::Serialization<MessageT> serialization;
       serialization.serialize_message(&message, serialized_msg.get());
       return write(
         serialized_msg, topic_name, rosidl_generator_traits::name<MessageT>(), time, sequence_number);
     }
   
     writer_interfaces::BaseWriterInterface & get_implementation_handle() const
     {
       return *writer_impl_;
     }
   
     void add_event_callbacks(bag_events::WriterEventCallbacks & callbacks);
   
     [[nodiscard]] bool has_callback_for_event(bag_events::BagEvent event) const;
   
   private:
     std::mutex writer_mutex_;
     std::unique_ptr<rosbag2_cpp::writer_interfaces::BaseWriterInterface> writer_impl_;
   };
   
   }  // namespace rosbag2_cpp
   
   #ifdef _WIN32
   # pragma warning(pop)
   #endif
   
   #endif  // ROSBAG2_CPP__WRITER_HPP_