Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines helper functions for the standard library.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <array>
      10             : #include <chrono>
      11             : #include <cstdio>
      12             : #include <ctime>
      13             : #include <deque>
      14             : #include <list>
      15             : #include <map>
      16             : #include <memory>
      17             : #include <optional>
      18             : #include <set>
      19             : #include <sstream>
      20             : #include <string>
      21             : #include <tuple>
      22             : #include <unordered_map>
      23             : #include <unordered_set>
      24             : #include <utility>
      25             : #include <vector>
      26             : 
      27             : #include "Utilities/PrintHelpers.hpp"
      28             : #include "Utilities/Requires.hpp"
      29             : #include "Utilities/StlStreamDeclarations.hpp"
      30             : #include "Utilities/TypeTraits/IsStreamable.hpp"
      31             : 
      32             : namespace StdHelpers_detail {
      33             : 
      34             : // Helper classes for operator<< for tuples
      35             : template <size_t N>
      36             : struct TuplePrinter {
      37             :   template <typename... Args>
      38             :   static std::ostream& print(std::ostream& os, const std::tuple<Args...>& t) {
      39             :     TuplePrinter<N - 1>::print(os, t);
      40             :     os << ",";
      41             :     print_value(os, std::get<N - 1>(t));
      42             :     return os;
      43             :   }
      44             : };
      45             : 
      46             : template <>
      47             : struct TuplePrinter<1> {
      48             :   template <typename... Args>
      49             :   static std::ostream& print(std::ostream& os, const std::tuple<Args...>& t) {
      50             :     print_value(os, std::get<0>(t));
      51             :     return os;
      52             :   }
      53             : };
      54             : 
      55             : template <>
      56             : struct TuplePrinter<0> {
      57             :   template <typename... Args>
      58             :   static std::ostream& print(std::ostream& os,
      59             :                              const std::tuple<Args...>& /*t*/) {
      60             :     return os;
      61             :   }
      62             : };
      63             : }  // namespace StdHelpers_detail
      64             : 
      65             : /*!
      66             :  * \ingroup UtilitiesGroup
      67             :  * \brief Output the items of a std::list
      68             :  */
      69             : template <typename T>
      70           1 : inline std::ostream& operator<<(std::ostream& os, const std::list<T>& v) {
      71             :   sequence_print_helper(os, std::begin(v), std::end(v));
      72             :   return os;
      73             : }
      74             : 
      75             : /*!
      76             :  * \ingroup UtilitiesGroup
      77             :  * \brief Output the items of a std::vector
      78             :  */
      79             : template <typename T>
      80           1 : inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
      81             :   sequence_print_helper(os, std::begin(v), std::end(v));
      82             :   return os;
      83             : }
      84             : 
      85             : /*!
      86             :  * \ingroup UtilitiesGroup
      87             :  * \brief Output the items of a std::deque
      88             :  */
      89             : template <typename T>
      90           1 : inline std::ostream& operator<<(std::ostream& os, const std::deque<T>& v) {
      91             :   sequence_print_helper(os, std::begin(v), std::end(v));
      92             :   return os;
      93             : }
      94             : 
      95             : /*!
      96             :  * \ingroup UtilitiesGroup
      97             :  * \brief Output the items of a std::array
      98             :  */
      99             : template <typename T, size_t N>
     100           1 : inline std::ostream& operator<<(std::ostream& os, const std::array<T, N>& a) {
     101             :   sequence_print_helper(os, begin(a), end(a));
     102             :   return os;
     103             : }
     104             : 
     105             : /*!
     106             :  * \ingroup UtilitiesGroup
     107             :  * \brief Stream operator for tuples
     108             :  */
     109             : template <typename... Args>
     110           1 : inline std::ostream& operator<<(std::ostream& os,
     111             :                                 const std::tuple<Args...>& t) {
     112             :   os << "(";
     113             :   StdHelpers_detail::TuplePrinter<sizeof...(Args)>::print(os, t);
     114             :   os << ")";
     115             :   return os;
     116             : }
     117             : 
     118             : /*!
     119             :  * \ingroup UtilitiesGroup
     120             :  * \brief Output all the key, value pairs of a std::unordered_map
     121             :  */
     122             : template <typename K, typename V, typename H>
     123           1 : inline std::ostream& operator<<(std::ostream& os,
     124             :                                 const std::unordered_map<K, V, H>& m) {
     125             :   unordered_print_helper(
     126             :       os, begin(m), end(m),
     127             :       [](std::ostream& out,
     128             :          const typename std::unordered_map<K, V, H>::value_type& value) {
     129             :         out << "[";
     130             :         print_value(out, value.first);
     131             :         out << ",";
     132             :         print_value(out, value.second);
     133             :         out << "]";
     134             :       });
     135             :   return os;
     136             : }
     137             : 
     138             : /*!
     139             :  * \ingroup UtilitiesGroup
     140             :  * \brief Output all the key, value pairs of a std::map
     141             :  */
     142             : template <typename K, typename V, typename C>
     143           1 : inline std::ostream& operator<<(std::ostream& os, const std::map<K, V, C>& m) {
     144             :   sequence_print_helper(
     145             :       os, begin(m), end(m),
     146             :       [](std::ostream& out,
     147             :          const typename std::map<K, V, C>::value_type& value) {
     148             :         out << "[";
     149             :         print_value(out, value.first);
     150             :         out << ",";
     151             :         print_value(out, value.second);
     152             :         out << "]";
     153             :       });
     154             :   return os;
     155             : }
     156             : 
     157             : /*!
     158             :  * \ingroup UtilitiesGroup
     159             :  * \brief Output the items of a std::unordered_set
     160             :  */
     161             : template <typename T, typename H>
     162           1 : inline std::ostream& operator<<(std::ostream& os,
     163             :                                 const std::unordered_set<T, H>& v) {
     164             :   unordered_print_helper(os, std::begin(v), std::end(v));
     165             :   return os;
     166             : }
     167             : 
     168             : /*!
     169             :  * \ingroup UtilitiesGroup
     170             :  * \brief Output the items of a std::unordered_multiset
     171             :  */
     172             : template <typename T, typename H>
     173           1 : inline std::ostream& operator<<(std::ostream& os,
     174             :                                 const std::unordered_multiset<T, H>& v) {
     175             :   unordered_print_helper(os, std::begin(v), std::end(v));
     176             :   return os;
     177             : }
     178             : 
     179             : /*!
     180             :  * \ingroup UtilitiesGroup
     181             :  * \brief Output the items of a std::set
     182             :  */
     183             : template <typename T, typename C>
     184           1 : inline std::ostream& operator<<(std::ostream& os, const std::set<T, C>& v) {
     185             :   sequence_print_helper(os, std::begin(v), std::end(v));
     186             :   return os;
     187             : }
     188             : 
     189             : /*!
     190             :  * \ingroup UtilitiesGroup
     191             :  * \brief Stream operator for std::unique_ptr
     192             :  */
     193             : template <typename T, Requires<tt::is_streamable<std::ostream, T>::value>>
     194           1 : inline std::ostream& operator<<(std::ostream& os, const std::unique_ptr<T>& t) {
     195             :   return os << *t;
     196             : }
     197             : 
     198             : /*!
     199             :  * \ingroup UtilitiesGroup
     200             :  * \brief Stream operator for std::shared_ptr
     201             :  */
     202             : template <typename T, Requires<tt::is_streamable<std::ostream, T>::value>>
     203           1 : inline std::ostream& operator<<(std::ostream& os, const std::shared_ptr<T>& t) {
     204             :   return os << *t;
     205             : }
     206             : 
     207             : /*!
     208             :  * \ingroup UtilitiesGroup
     209             :  * \brief Stream operator for std::pair
     210             :  */
     211             : template <typename T, typename U>
     212           1 : inline std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& t) {
     213             :   os << "(";
     214             :   print_value(os, t.first);
     215             :   os << ", ";
     216             :   print_value(os, t.second);
     217             :   os << ")";
     218             :   return os;
     219             : }
     220             : 
     221             : /*!
     222             :  * \ingroup UtilitiesGroup
     223             :  * \brief Stream operator for std::optional
     224             :  */
     225             : template <typename T>
     226           1 : inline std::ostream& operator<<(std::ostream& os, const std::optional<T>& t) {
     227             :   // Match boost::optional behavior and print "--" when invalid
     228             :   if (t.has_value()) {
     229             :     print_value(os, t.value());
     230             :     return os;
     231             :   } else {
     232             :     return os << "--";
     233             :   }
     234             : }
     235             : 
     236             : /*!
     237             :  * \ingroup UtilitiesGroup
     238             :  * \brief Equivalent to `os << t`.
     239             :  *
     240             :  * For some reason this sometimes works when trying to stream directly
     241             :  * doesn't find our STL container stream operators.
     242             :  */
     243             : template <typename T>
     244           1 : void print_stl(std::ostream& os, const T& t) {
     245             :   using ::operator<<;
     246             :   os << t;
     247             : }
     248             : 
     249             : /*!
     250             :  * \ingroup UtilitiesGroup
     251             :  * \brief Construct a string containing the keys of a std::unordered_map
     252             :  */
     253             : template <typename K, typename V, typename H>
     254           1 : inline std::string keys_of(const std::unordered_map<K, V, H>& m) {
     255             :   std::ostringstream os;
     256             :   unordered_print_helper(
     257             :       os, begin(m), end(m),
     258             :       [](std::ostream& out,
     259             :          const typename std::unordered_map<K, V, H>::value_type& value) {
     260             :         print_value(out, value.first);
     261             :       });
     262             :   return os.str();
     263             : }
     264             : 
     265             : /*!
     266             :  * \ingroup UtilitiesGroup
     267             :  * \brief Construct a string containing the keys of a std::map
     268             :  */
     269             : template <typename K, typename V, typename C>
     270           1 : inline std::string keys_of(const std::map<K, V, C>& m) {
     271             :   std::ostringstream os;
     272             :   sequence_print_helper(
     273             :       os, begin(m), end(m),
     274             :       [](std::ostream& out,
     275             :          const typename std::map<K, V, C>::value_type& value) {
     276             :         print_value(out, value.first);
     277             :       });
     278             :   return os.str();
     279             : }
     280             : 
     281             : /*!
     282             :  * \ingroup UtilitiesGroup
     283             :  * \brief Format a string like printf
     284             :  *
     285             :  * Given a formatting string and arguments this returns the corresponding
     286             :  * string. Similar to printf but using std::strings.
     287             :  */
     288             : template <typename... Args>
     289           1 : std::string formatted_string(const std::string& fmt, Args... args) {
     290             : #pragma GCC diagnostic push
     291             : #pragma GCC diagnostic ignored "-Wformat-nonliteral"
     292             :   // clang-tidy: do not use snprintf
     293             :   auto requiredBytes = static_cast<size_t>(std::snprintf(  // NOLINT
     294             :                            nullptr, 0, fmt.c_str(), args...)) +
     295             :                        1;
     296             :   std::string rtn;
     297             :   rtn.resize(requiredBytes);
     298             :   // clang-tidy: do not use snprintf
     299             :   std::snprintf(&rtn[0], requiredBytes, fmt.c_str(), args...);  // NOLINT
     300             : #pragma GCC diagnostic pop
     301             :   if (rtn[rtn.size() - 1] == '\0') {
     302             :     rtn.resize(rtn.size() - 1);
     303             :   }
     304             :   return rtn;
     305             : }
     306             : 
     307             : /*!
     308             :  * \ingroup UtilitiesGroup
     309             :  * \brief Get the current date and time
     310             :  */
     311           1 : inline std::string current_date_and_time() {
     312             :   const auto now =
     313             :       std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
     314             :   return std::ctime(&now);
     315             : }