Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <type_traits>
       7             : #include <utility>
       8             : 
       9             : #include "Utilities/ErrorHandling/Assert.hpp"
      10             : #include "Utilities/ErrorHandling/Error.hpp"
      11             : #include "Utilities/Gsl.hpp"
      12             : #include "Utilities/PrettyType.hpp"
      13             : 
      14             : namespace Parallel {
      15             : /// \ingroup ParallelGroup
      16             : /// \brief Structs that have `insert_into_inbox` methods for commonly used
      17             : /// cases.
      18             : ///
      19             : /// Inbox tags can inherit from the inserters to gain the `insert_into_inbox`
      20             : /// static method used by the parallel infrastructure to store data in the
      21             : /// inboxes. Collected in the `InboxInserters` namespace are implementations for
      22             : /// the most common types of data sent that one may encounter.
      23           1 : namespace InboxInserters {
      24             : /*!
      25             :  * \brief Inserter for inserting data that is received as the `value_type` (with
      26             :  * non-const `key_type`) of a map data structure.
      27             :  *
      28             :  * An example would be a `std::unordered_map<int, int>`, where the first `int`
      29             :  * is the "spatial" id of the parallel component array. The data type that is
      30             :  * sent to the component would be a `std::pair<int, int>`, or more generally a
      31             :  * `std::pair<key_type, mapped_type>`. The inbox tag would be:
      32             :  *
      33             :  * \snippet Test_InboxInserters.cpp map tag
      34             :  */
      35             : template <typename InboxTag>
      36           1 : struct Map {
      37             :   template <typename Inbox, typename TemporalId, typename ReceiveDataType>
      38           0 :   static bool insert_into_inbox(const gsl::not_null<Inbox*> inbox,
      39             :                                 const TemporalId& temporal_id,
      40             :                                 ReceiveDataType&& data) {
      41             :     static_assert(std::is_same<std::decay_t<TemporalId>,
      42             :                                typename InboxTag::temporal_id>::value,
      43             :                   "The temporal_id of the inbox tag does not match the "
      44             :                   "received temporal id.");
      45             :     auto& current_inbox = (*inbox)[temporal_id];
      46             :     ASSERT(0 == current_inbox.count(data.first),
      47             :            "Receiving data from the 'same' source twice. The message id is: "
      48             :                << data.first);
      49             :     if (not current_inbox.insert(std::forward<ReceiveDataType>(data)).second) {
      50             :       ERROR("Failed to insert data to receive at instance '"
      51             :             << temporal_id << "' with tag '"
      52             :             << pretty_type::get_name<InboxTag>() << "'.\n");
      53             :     }
      54             :     return true;
      55             :   }
      56             : };
      57             : 
      58             : /*!
      59             :  * \brief Inserter for inserting data that is received as the `value_type` of a
      60             :  * data structure that has an `insert(value_type&&)` member function.
      61             :  *
      62             :  * Can be used for receiving data into data structures like
      63             :  * `std::(unordered_)multiset`.
      64             :  *
      65             :  * \snippet Test_InboxInserters.cpp member insert tag
      66             :  */
      67             : template <typename InboxTag>
      68           1 : struct MemberInsert {
      69             :   template <typename Inbox, typename TemporalId, typename ReceiveDataType>
      70           0 :   static bool insert_into_inbox(const gsl::not_null<Inbox*> inbox,
      71             :                                 const TemporalId& temporal_id,
      72             :                                 ReceiveDataType&& data) {
      73             :     static_assert(std::is_same<std::decay_t<TemporalId>,
      74             :                                typename InboxTag::temporal_id>::value,
      75             :                   "The temporal_id of the inbox tag does not match the "
      76             :                   "received temporal id.");
      77             :     (*inbox)[temporal_id].insert(std::forward<ReceiveDataType>(data));
      78             :     return true;
      79             :   }
      80             : };
      81             : 
      82             : /*!
      83             :  * \brief Inserter for data that is inserted by copy/move.
      84             :  *
      85             :  * \snippet Test_InboxInserters.cpp value tag
      86             :  */
      87             : template <typename InboxTag>
      88           1 : struct Value {
      89             :   template <typename Inbox, typename TemporalId, typename ReceiveDataType>
      90           0 :   static bool insert_into_inbox(const gsl::not_null<Inbox*> inbox,
      91             :                                 const TemporalId& temporal_id,
      92             :                                 ReceiveDataType&& data) {
      93             :     static_assert(std::is_same<std::decay_t<TemporalId>,
      94             :                                typename InboxTag::temporal_id>::value,
      95             :                   "The temporal_id of the inbox tag does not match the "
      96             :                   "received temporal id.");
      97             :     (*inbox)[temporal_id] = std::forward<ReceiveDataType>(data);
      98             :     return true;
      99             :   }
     100             : };
     101             : 
     102             : /*!
     103             :  * \brief Inserter for inserting data that is received as the `value_type` of a
     104             :  * data structure that has an `push_back(value_type&&)` member function.
     105             :  *
     106             :  * Can be used for receiving data into data structures like
     107             :  * `std::vector`.
     108             :  *
     109             :  * \snippet Test_InboxInserters.cpp pushback tag
     110             :  */
     111             : template <typename InboxTag>
     112           1 : struct Pushback {
     113             :   template <typename Inbox, typename TemporalId, typename ReceiveDataType>
     114           0 :   static bool insert_into_inbox(const gsl::not_null<Inbox*> inbox,
     115             :                                 const TemporalId& temporal_id,
     116             :                                 ReceiveDataType&& data) {
     117             :     static_assert(std::is_same<std::decay_t<TemporalId>,
     118             :                                typename InboxTag::temporal_id>::value,
     119             :                   "The temporal_id of the inbox tag does not match the "
     120             :                   "received temporal id.");
     121             :     (*inbox)[temporal_id].push_back(std::forward<ReceiveDataType>(data));
     122             :     return true;
     123             :   }
     124             : };
     125             : }  // namespace InboxInserters
     126             : }  // namespace Parallel