const and noexcept

Author: frs69wq

include/dtlmod/DTL.hpp

@@ -28,8 +28,8 @@ class DTL {
 
 protected:
   /// \cond EXCLUDE_FROM_DOCUMENTATION
-  void lock() { mutex_->lock(); }
-  void unlock() { mutex_->unlock(); }
+  void lock() noexcept { mutex_->lock(); }
+  void unlock() noexcept { mutex_->unlock(); }
   /// \endcond
 
 public:
@@ -49,7 +49,7 @@ class DTL {
 
   /// @brief Helper function to check whether some simulated actors are currently connected to the DTL.
   /// @return A boolean value.
-  bool has_active_connections() const { return !active_connections_.empty(); }
+  bool has_active_connections() const noexcept { return !active_connections_.empty(); }
 
   /// @brief Add a data stream to the Data Transport Layer.
   /// @param name The name of the Stream to add to the DTL.
@@ -58,7 +58,7 @@ class DTL {
 
   /// @brief Retrieve all streams declared in the Data Transport Layer.
   /// @return a map of handlers on Stream objects with their names as keys.
-  const std::unordered_map<std::string, std::shared_ptr<Stream>>& get_all_streams() const { return streams_; }
+  const std::unordered_map<std::string, std::shared_ptr<Stream>>& get_all_streams() const noexcept { return streams_; }
 
   /// @brief Retrieve a data stream from the Data Transport Layer by its name.
   /// @param name The name of the Stream to retrieve.

include/dtlmod/Engine.hpp

@@ -82,20 +82,26 @@ class Engine {
 
   virtual void create_transport(const Transport::Method& transport_method) = 0;
 
-  void set_transport(std::shared_ptr<Transport> transport) { transport_ = transport; }
-  [[nodiscard]] std::shared_ptr<Transport> get_transport() const { return transport_; }
+  void set_transport(std::shared_ptr<Transport> transport) noexcept { transport_ = transport; }
+  [[nodiscard]] std::shared_ptr<Transport> get_transport() const noexcept { return transport_; }
 
   void add_publisher(sg4::ActorPtr actor);
-  void rm_publisher(sg4::ActorPtr actor) { publishers_.erase(actor); }
-  [[nodiscard]] bool is_publisher(sg4::ActorPtr actor) const { return publishers_.find(actor) != publishers_.end(); }
+  void rm_publisher(sg4::ActorPtr actor) noexcept { publishers_.erase(actor); }
+  [[nodiscard]] bool is_publisher(sg4::ActorPtr actor) const noexcept
+  {
+    return publishers_.find(actor) != publishers_.end();
+  }
   // Synchronize publishers on engine closing
   [[nodiscard]] int is_last_publisher() const { return (pub_barrier_ && pub_barrier_->wait()); }
 
   void add_subscriber(sg4::ActorPtr actor);
-  void rm_subscriber(sg4::ActorPtr actor) { subscribers_.erase(actor); }
-  [[nodiscard]] bool is_subscriber(sg4::ActorPtr actor) const { return subscribers_.find(actor) != subscribers_.end(); }
+  void rm_subscriber(sg4::ActorPtr actor) noexcept { subscribers_.erase(actor); }
+  [[nodiscard]] bool is_subscriber(sg4::ActorPtr actor) const noexcept
+  {
+    return subscribers_.find(actor) != subscribers_.end();
+  }
   // Synchronize subscribers on engine closing
-  [[nodiscard]] int is_last_subscriber() const { return subscribers_.empty(); }
+  [[nodiscard]] int is_last_subscriber() const noexcept { return subscribers_.empty(); }
 
   void set_metadata_file_name();
   /// \endcond
@@ -108,19 +114,21 @@ class Engine {
   }
   virtual ~Engine() = default;
   // Public accessors for Transport classes to access ActivitySets
-  [[nodiscard]] sg4::ActivitySet& get_pub_transaction() { return pub_transaction_; }
-  [[nodiscard]] sg4::ActivitySet& get_sub_transaction() { return sub_transaction_; }
-  [[nodiscard]] const std::set<sg4::ActorPtr>& get_publishers() const { return publishers_; }
-  [[nodiscard]] size_t get_num_publishers() const { return publishers_.size(); }
-  [[nodiscard]] size_t get_num_subscribers() const { return subscribers_.size(); }
+  [[nodiscard]] const sg4::ActivitySet& get_pub_transaction() const noexcept { return pub_transaction_; }
+  [[nodiscard]] sg4::ActivitySet& get_pub_transaction() noexcept { return pub_transaction_; }
+  [[nodiscard]] const sg4::ActivitySet& get_sub_transaction() const noexcept { return sub_transaction_; }
+  [[nodiscard]] sg4::ActivitySet& get_sub_transaction() noexcept { return sub_transaction_; }
+  [[nodiscard]] const std::set<sg4::ActorPtr>& get_publishers() const noexcept { return publishers_; }
+  [[nodiscard]] size_t get_num_publishers() const noexcept { return publishers_.size(); }
+  [[nodiscard]] size_t get_num_subscribers() const noexcept { return subscribers_.size(); }
   /// \endcond
 
   /// @brief Helper function to print out the name of the Engine.
   /// @return the corresponding string
-  [[nodiscard]] const std::string& get_name() const { return name_; }
+  [[nodiscard]] const std::string& get_name() const noexcept { return name_; }
   /// @brief Helper function to print out the name of the Engine.
   /// @return the corresponding C-string
-  [[nodiscard]] const char* get_cname() const { return name_.c_str(); }
+  [[nodiscard]] const char* get_cname() const noexcept { return name_.c_str(); }
 
   /// @brief Start a transaction on an Engine.
   void begin_transaction();
@@ -143,11 +151,11 @@ class Engine {
 
   /// @brief Get the id of the current transaction (on the Publish side).
   /// @return The id of the ongoing transaction.
-  [[nodiscard]] unsigned int get_current_transaction() const { return current_pub_transaction_id_; }
+  [[nodiscard]] unsigned int get_current_transaction() const noexcept { return current_pub_transaction_id_; }
 
   /// @brief Get the name of the file in which the engine stored metadata
   /// @return The name of the file.
-  [[nodiscard]] const std::string& get_metadata_file_name() const { return metadata_file_; }
+  [[nodiscard]] const std::string& get_metadata_file_name() const noexcept { return metadata_file_; }
 
   /// @brief Close the Engine associated to a Stream.
   void close();

include/dtlmod/FileTransport.hpp

@@ -31,18 +31,18 @@ class FileTransport : public Transport {
   void close_pub_files() const;
   void close_sub_files(sg4::ActorPtr self);
   const std::vector<std::pair<std::shared_ptr<sgfs::File>, sg_size_t>>&
-  get_to_write_in_transaction_by_actor(sg4::ActorPtr actor)
+  get_to_write_in_transaction_by_actor(sg4::ActorPtr actor) noexcept
   {
     return to_write_in_transaction_[actor];
   }
-  void clear_to_write_in_transaction(sg4::ActorPtr actor) { to_write_in_transaction_[actor].clear(); }
+  void clear_to_write_in_transaction(sg4::ActorPtr actor) noexcept { to_write_in_transaction_[actor].clear(); }
 
   const std::vector<std::pair<std::shared_ptr<sgfs::File>, sg_size_t>>&
-  get_to_read_in_transaction_by_actor(sg4::ActorPtr actor)
+  get_to_read_in_transaction_by_actor(sg4::ActorPtr actor) noexcept
   {
     return to_read_in_transaction_[actor];
   }
-  void clear_to_read_in_transaction(sg4::ActorPtr actor) { to_read_in_transaction_[actor].clear(); }
+  void clear_to_read_in_transaction(sg4::ActorPtr actor) noexcept { to_read_in_transaction_[actor].clear(); }
 
 public:
   void put(std::shared_ptr<Variable> var, size_t size) override;

include/dtlmod/Metadata.hpp

@@ -40,8 +40,8 @@ class Metadata {
                        const std::string& filename, sg4::ActorPtr publisher);
 
 public:
-  explicit Metadata(Variable* variable) : variable_(variable) {}
-  unsigned int get_current_transaction() const
+  explicit Metadata(Variable* variable) noexcept : variable_(variable) {}
+  unsigned int get_current_transaction() const noexcept
   {
     return transaction_infos_.empty() ? 0 : (transaction_infos_.rbegin())->first;
   }

include/dtlmod/StagingTransport.hpp

@@ -26,12 +26,12 @@ class StagingTransport : public Transport {
 
   // Create a message queue to receive request for variable pieces from subscribers
   void set_publisher_put_requests_mq(const std::string& publisher_name);
-  [[nodiscard]] sg4::MessageQueue* get_publisher_put_requests_mq(const std::string& publisher_name) const;
-  [[nodiscard]] bool pending_put_requests_exist_for(const std::string& pub_name)
+  [[nodiscard]] sg4::MessageQueue* get_publisher_put_requests_mq(const std::string& publisher_name) const noexcept;
+  [[nodiscard]] bool pending_put_requests_exist_for(const std::string& pub_name) noexcept
   {
     return not pending_put_requests_[pub_name].empty();
   }
-  [[nodiscard]] sg4::ActivityPtr wait_any_pending_put_request_for(const std::string& pub_name)
+  [[nodiscard]] sg4::ActivityPtr wait_any_pending_put_request_for(const std::string& pub_name) noexcept
   {
     return pending_put_requests_[pub_name].wait_any();
   }

include/dtlmod/Stream.hpp

@@ -51,16 +51,17 @@ class Stream : public std::enable_shared_from_this<Stream> {
 
 protected:
   /// \cond EXCLUDE_FROM_DOCUMENTATION
-  [[nodiscard]] const Transport::Method& get_transport_method() const { return transport_method_; }
-  [[nodiscard]] const std::unordered_map<std::string, std::shared_ptr<Variable>>& get_all_variables_internal() const
+  [[nodiscard]] const Transport::Method& get_transport_method() const noexcept { return transport_method_; }
+  [[nodiscard]] const std::unordered_map<std::string, std::shared_ptr<Variable>>&
+  get_all_variables_internal() const noexcept
   {
     return variables_;
   }
-  [[nodiscard]] const char* mode_to_str(Mode mode) const
+  [[nodiscard]] const char* mode_to_str(Mode mode) const noexcept
   {
     return (mode == Mode::Publish) ? "Mode::Publish" : "Mode::Subscribe";
   }
-  void close() { engine_ = nullptr; }
+  void close() noexcept { engine_ = nullptr; }
 
   // Helper methods for Stream::open
   void validate_open_parameters(const std::string& name, Mode mode) const;
@@ -79,10 +80,10 @@ class Stream : public std::enable_shared_from_this<Stream> {
 
   /// @brief Helper function to print out the name of the Stream.
   /// @return The corresponding string
-  [[nodiscard]] const std::string& get_name() const { return name_; }
+  [[nodiscard]] const std::string& get_name() const noexcept { return name_; }
   /// @brief Helper function to print out the name of the Stream.
   /// @return The corresponding C-string
-  [[nodiscard]] const char* get_cname() const { return name_.c_str(); }
+  [[nodiscard]] const char* get_cname() const noexcept { return name_.c_str(); }
   /// @brief Helper function to print out the Engine::Type of the Stream.
   /// @return The corresponding C-string
   [[nodiscard]] const char* get_engine_type_str() const;
@@ -91,13 +92,13 @@ class Stream : public std::enable_shared_from_this<Stream> {
   [[nodiscard]] const char* get_transport_method_str() const;
   /// @brief Helper function to know the access Mode of the Stream.
   /// @return The corresponding Stream::Mode
-  [[nodiscard]] Mode get_access_mode() const { return access_mode_; }
+  [[nodiscard]] Mode get_access_mode() const noexcept { return access_mode_; }
   /// @brief Helper function to print out the access Mode of the Stream.
   /// @return The corresponding C-string
-  [[nodiscard]] const char* get_access_mode_str() const { return mode_to_str(access_mode_); }
+  [[nodiscard]] const char* get_access_mode_str() const noexcept { return mode_to_str(access_mode_); }
   /// @brief Helper function to know if the Stream does export metadata or not
   /// @return a boolean indicating if the Stream does export metadata or not
-  [[nodiscard]] bool does_export_metadata() const { return metadata_export_; }
+  [[nodiscard]] bool does_export_metadata() const noexcept { return metadata_export_; }
 
   /// @brief Stream configuration function: set the Engine type to create.
   /// @param engine_type The type of Engine to create when opening the Stream.
@@ -124,10 +125,10 @@ class Stream : public std::enable_shared_from_this<Stream> {
 
   /// @brief Helper function to obtain the number of actors connected to Stream in Mode::Publish.
   /// @return The number of publishers for that Stream.
-  [[nodiscard]] size_t get_num_publishers() const { return engine_->get_num_publishers(); }
+  [[nodiscard]] size_t get_num_publishers() const noexcept { return engine_->get_num_publishers(); }
   /// @brief Helper function to obtain the number of actors connected to Stream in Mode::Subscribe.
   /// @return The number of subscribers for that Stream.
-  [[nodiscard]] size_t get_num_subscribers() const { return engine_->get_num_subscribers(); }
+  [[nodiscard]] size_t get_num_subscribers() const noexcept { return engine_->get_num_subscribers(); }
 
   /******* Variable Factory *******/
 

include/dtlmod/Transport.hpp

@@ -32,10 +32,10 @@ class Transport {
 public:
   enum class Method { Undefined, File, Mailbox, MQ };
 
-  explicit Transport(Engine* engine) : engine_(engine) {}
+  explicit Transport(Engine* engine) noexcept : engine_(engine) {}
   virtual ~Transport() = default;
 
-  Engine* get_engine() { return engine_; }
+  Engine* get_engine() noexcept { return engine_; }
 
   virtual void put(std::shared_ptr<Variable> var, size_t simulated_size_in_bytes) = 0;
   virtual void get(std::shared_ptr<Variable> var)                                 = 0;

include/dtlmod/Variable.hpp

@@ -44,10 +44,10 @@ class Variable {
 public:
   /// \cond EXCLUDE_FROM_DOCUMENTATION
   // Public accessors for Transport classes
-  void set_transaction_start(unsigned int start) { transaction_start_ = start; }
-  [[nodiscard]] unsigned int get_transaction_start() const { return transaction_start_; }
-  void set_transaction_count(unsigned int count) { transaction_count_ = count; }
-  [[nodiscard]] unsigned int get_transaction_count() const { return transaction_count_; }
+  void set_transaction_start(unsigned int start) noexcept { transaction_start_ = start; }
+  [[nodiscard]] unsigned int get_transaction_start() const noexcept { return transaction_start_; }
+  void set_transaction_count(unsigned int count) noexcept { transaction_count_ = count; }
+  [[nodiscard]] unsigned int get_transaction_count() const noexcept { return transaction_count_; }
 
   void set_local_start_and_count(sg4::ActorPtr actor,
                                  const std::pair<std::vector<size_t>, std::vector<size_t>>& local_start_and_count)
@@ -86,17 +86,17 @@ class Variable {
 
   /// @brief Helper function to print out the name of the Variable.
   /// @return The corresponding string.
-  [[nodiscard]] const std::string& get_name() const { return name_; }
+  [[nodiscard]] const std::string& get_name() const noexcept { return name_; }
   /// @brief Helper function to print out the name of the Variable.
   /// @return The corresponding C-string.
-  [[nodiscard]] const char* get_cname() const { return name_.c_str(); }
+  [[nodiscard]] const char* get_cname() const noexcept { return name_.c_str(); }
 
   /// @brief Get the shape of the Variable.
   /// @return A vector of the respective size in each dimension of the Variable.
-  [[nodiscard]] const std::vector<size_t>& get_shape() const { return shape_; }
+  [[nodiscard]] const std::vector<size_t>& get_shape() const noexcept { return shape_; }
   /// @brief Get the size of the elements stored in the Variable.
   /// @return The elements' size.
-  [[nodiscard]] size_t get_element_size() const { return element_size_; }
+  [[nodiscard]] size_t get_element_size() const noexcept { return element_size_; }
 
   /// @brief Get the global size of the Variable.
   /// @return The computed size.

src/DTL.cpp

@@ -103,7 +103,8 @@ __attribute__((noreturn)) void DTL::connection_manager_init(std::shared_ptr<DTL>
       handler_mq->put_init(&dtl)->detach();
     } else { // Disconnection
       dtl->connection_manager_disconnect(sender);
-      handler_mq->put_init(new bool(true))->detach();
+      auto payload = std::make_unique<bool>(true);
+      handler_mq->put_init(payload.release())->detach();
       if (!dtl->has_active_connections())
         XBT_WARN("The DTL has no active connection");
     }
@@ -126,14 +127,16 @@ void DTL::create(const std::string& filename)
 
 std::shared_ptr<DTL> DTL::connect()
 {
-  sg4::MessageQueue::by_name("dtlmod::connection_manager_connect")->put(new bool(true));
+  auto payload = std::make_unique<bool>(true);
+  sg4::MessageQueue::by_name("dtlmod::connection_manager_connect")->put(payload.release());
   const auto* handle = sg4::MessageQueue::by_name("dtlmod::connection_manager_handle")->get<std::shared_ptr<DTL>>();
   return *handle;
 }
 
 void DTL::disconnect()
 {
-  sg4::MessageQueue::by_name("dtlmod::connection_manager_connect")->put(new bool(false));
+  auto payload = std::make_unique<bool>(false);
+  sg4::MessageQueue::by_name("dtlmod::connection_manager_connect")->put(payload.release());
   sg4::MessageQueue::by_name("dtlmod::connection_manager_handle")->get_unique<bool>();
 }
 

src/StagingTransport.cpp

@@ -25,7 +25,7 @@ void StagingTransport::set_publisher_put_requests_mq(const std::string& publishe
   publisher_put_requests_mq_[publisher_name] = sg4::MessageQueue::by_name(publisher_name);
 }
 
-sg4::MessageQueue* StagingTransport::get_publisher_put_requests_mq(const std::string& publisher_name) const
+sg4::MessageQueue* StagingTransport::get_publisher_put_requests_mq(const std::string& publisher_name) const noexcept
 {
   return publisher_put_requests_mq_.at(publisher_name);
 }