Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <ostream>
       7             : #include <pup.h>
       8             : #include <type_traits>
       9             : #include <utility>
      10             : 
      11             : /*!
      12             :  * \ingroup DataStructuresGroup
      13             :  * \brief A data structure that contains an ID and data associated with that ID.
      14             :  */
      15             : template <typename IdType, typename DataType>
      16           1 : struct IdPair {
      17           0 :   IdPair();
      18           0 :   IdPair(IdType id_in, DataType data_in);
      19             : 
      20           0 :   IdType id{};
      21           0 :   DataType data{};
      22             : };
      23             : 
      24             : template <typename IdType, typename DataType>
      25             : IdPair<IdType, DataType>::IdPair() = default;
      26             : 
      27             : template <typename IdType, typename DataType>
      28             : IdPair<IdType, DataType>::IdPair(IdType id_in, DataType data_in)
      29             :     : id(std::move(id_in)), data(std::move(data_in)) {}
      30             : 
      31             : template <typename IdType, typename DataType>
      32           0 : IdPair<std::decay_t<IdType>, std::decay_t<DataType>> make_id_pair(
      33             :     IdType&& id, DataType&& data) {
      34             :   return {std::forward<IdType>(id), std::forward<DataType>(data)};
      35             : }
      36             : 
      37             : /// \cond
      38             : // We write the pup function as a free function to keep IdPair a POD
      39             : // clang-tidy: no non-const references
      40             : template <typename IdType, typename DataType>
      41             : void pup(PUP::er& p, IdPair<IdType, DataType>& t) {  // NOLINT
      42             :   p | t.id;
      43             :   p | t.data;
      44             : }
      45             : 
      46             : // clang-tidy: no non-const references
      47             : template <typename IdType, typename DataType>
      48             : void operator|(PUP::er& p, IdPair<IdType, DataType>& t) {  // NOLINT
      49             :   pup(p, t);
      50             : }
      51             : 
      52             : template <typename IdType, typename DataType>
      53             : bool operator==(const IdPair<IdType, DataType>& lhs,
      54             :                 const IdPair<IdType, DataType>& rhs) {
      55             :   return lhs.id == rhs.id and lhs.data == rhs.data;
      56             : }
      57             : 
      58             : template <typename IdType, typename DataType>
      59             : bool operator!=(const IdPair<IdType, DataType>& lhs,
      60             :                 const IdPair<IdType, DataType>& rhs) {
      61             :   return not(lhs == rhs);
      62             : }
      63             : 
      64             : template <typename IdType, typename DataType>
      65             : std::ostream& operator<<(std::ostream& os, const IdPair<IdType, DataType>& t) {
      66             :   return os << '(' << t.id << ',' << t.data << ')';
      67             : }
      68             : /// \endcond