Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Declares stream operators for STL containers
       6              : 
       7              : #pragma once
       8              : 
       9              : // Suppress warnings from this header since they can occur from not including
      10              : // StdHelpers later. This header is used only in TypeTraits.hpp so that
      11              : // is_streamable works correctly for STL types that have stream operators
      12              : // defined.
      13              : #ifdef __GNUC__
      14              : #pragma GCC system_header
      15              : #endif
      16              : 
      17              : #include <array>
      18              : #include <deque>
      19              : #include <list>
      20              : #include <map>
      21              : #include <memory>
      22              : #include <optional>
      23              : #include <set>
      24              : #include <tuple>
      25              : #include <unordered_map>
      26              : #include <unordered_set>
      27              : #include <vector>
      28              : 
      29              : #include "Utilities/Requires.hpp"
      30              : 
      31              : namespace tt {
      32              : template <typename S, typename T, typename>
      33              : struct is_streamable;
      34              : }  // namespace tt
      35              : 
      36              : template <typename T>
      37              : std::ostream& operator<<(std::ostream& os, const std::list<T>& v);
      38              : 
      39              : template <typename T>
      40              : std::ostream& operator<<(std::ostream& os, const std::vector<T>& v);
      41              : 
      42              : template <typename T>
      43              : std::ostream& operator<<(std::ostream& os, const std::deque<T>& v);
      44              : 
      45              : template <typename T, size_t N>
      46              : std::ostream& operator<<(std::ostream& os, const std::array<T, N>& a);
      47              : 
      48              : template <typename... Args>
      49              : std::ostream& operator<<(std::ostream& os, const std::tuple<Args...>& t);
      50              : 
      51              : template <typename K, typename V, typename H>
      52              : inline std::ostream& operator<<(std::ostream& os,
      53              :                                 const std::unordered_map<K, V, H>& m);
      54              : 
      55              : template <typename K, typename V, typename C>
      56              : inline std::ostream& operator<<(std::ostream& os, const std::map<K, V, C>& m);
      57              : 
      58              : template <typename T, typename H>
      59              : std::ostream& operator<<(std::ostream& os, const std::unordered_set<T, H>& v);
      60              : 
      61              : template <typename T, typename H>
      62              : std::ostream& operator<<(std::ostream& os,
      63              :                          const std::unordered_multiset<T, H>& v);
      64              : 
      65              : template <typename T, typename C>
      66              : inline std::ostream& operator<<(std::ostream& os, const std::set<T, C>& v);
      67              : 
      68              : template <typename T,
      69              :           Requires<tt::is_streamable<std::ostream, T, void>::value> = nullptr>
      70              : std::ostream& operator<<(std::ostream& os, const std::unique_ptr<T>& t);
      71              : 
      72              : template <typename T,
      73              :           Requires<tt::is_streamable<std::ostream, T, void>::value> = nullptr>
      74              : std::ostream& operator<<(std::ostream& os, const std::shared_ptr<T>& t);
      75              : 
      76              : template <typename T, typename U>
      77              : std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& t);
      78              : 
      79              : template <typename T>
      80              : std::ostream& operator<<(std::ostream& os, const std::optional<T>& t);