generic_stream_output.hpp

Go to the documentation of this file.

#pragma once
#include "stream_insertable.hpp"
#include "any.hpp"
#include "optional.hpp"
#include <array>
#include <deque>
#include <stdexcept>
#include <functional>
#include <forward_list>
#include <iostream>
#include <iomanip>
#include <list>
#include <map>
#include <set>
#include <system_error>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <variant>
#include <vector>

extern std::unordered_map<std::type_index, std::function<std::string(xtd::any const&)>> __any_stringer__;
 
inline auto operator <<(std::ostream& os, const std::exception& value) -> std::ostream& {
  return os << "exception: " << value.what();
}
 
template<typename value_t>
requires xtd::stream_insertable<value_t>
inline auto operator <<(std::ostream& os, const std::optional<value_t>& value) -> std::ostream& {
  if (!value.has_value()) return os << "(null)";
  return os << "(" << value.value() << ")";
}
 
template<typename value_t>
requires (!xtd::stream_insertable<value_t>)
inline auto operator <<(std::ostream& os, const std::optional<value_t>&) -> std::ostream& {
  return os << "(unregistered)";
}
 
template<typename type1_t, typename type2_t>
requires xtd::stream_insertable<type1_t> && xtd::stream_insertable<type2_t>
inline auto operator <<(std::ostream& os, const std::pair<type1_t, type2_t>& value) -> std::ostream& {
  return os << "(" << value.first << ", " << value.second << ")";
}
 
template<typename type1_t, typename type2_t>
requires (!xtd::stream_insertable<type1_t> || !xtd::stream_insertable<type2_t>)
inline auto operator <<(std::ostream& os, const std::pair<type1_t, type2_t>& value) -> std::ostream& {
  return os << "( ,  )";
}
 
template<typename type_t, unsigned n_t, unsigned last_t>
requires xtd::stream_insertable<decltype(std::get<n_t>(std::declval<type_t>()))>
struct __xtd_console_tuple_printer {
  static auto print(std::ostream& os, const type_t& value) -> void {
    os << std::get<n_t>(value);
    if constexpr (n_t < last_t) os << ", ";
    if constexpr (n_t < last_t)
      __xtd_console_tuple_printer<type_t, n_t + 1, last_t>::print(os, value);
  }
};
 
template<typename ...types_t>
inline auto operator <<(std::ostream& os, const std::tuple<types_t ... >& value) -> std::ostream& {
  os << "(";
  __xtd_console_tuple_printer<std::tuple<types_t...>, 0, sizeof...(types_t) - 1>::print(os, value);
  return os << ")";
}
 
template<typename iterator_t>
requires xtd::stream_insertable<std::iter_value_t<iterator_t>>
inline auto __xtd_console_print_container(std::ostream& os, const iterator_t& begin, const iterator_t& end) -> void {
  for (auto it = begin; it != end; ++it) {
    os << (it != begin ? ", " : "") << *it;
  }
}
 
template<typename iterator_t>
requires (!xtd::stream_insertable<std::iter_value_t<iterator_t>>)
inline auto __xtd_console_print_container(std::ostream& os, const iterator_t& begin, const iterator_t& end) -> void {
  for (auto it = begin; it != end; ++it) {
    os << (it != begin ? ", " : "") << " ";
  }
}
 
template<typename iterator_t>
inline auto __xtd_console_print_sequence_container(std::ostream& os, const iterator_t& begin, const iterator_t& end) -> std::ostream& {
  os << "[";
  __xtd_console_print_container(os, begin, end);
  return os << "]";
}
 
template<typename type_t, size_t size_t>
inline auto operator <<(std::ostream& os, const std::array<type_t, size_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, values.begin(), values.end());
}
 
template<typename type_t, typename allocator_t = std::allocator < type_t>>
inline auto operator <<(std::ostream& os, const std::deque<type_t, allocator_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, values.begin(), values.end());
}
 
template<typename type_t, typename allocator_t = std::allocator<type_t>>
inline auto operator <<(std::ostream& os, const std::forward_list<type_t, allocator_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, values.begin(), values.end());
}
 
template<typename type_t>
inline auto operator <<(std::ostream& os, const std::initializer_list<type_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, values.begin(), values.end());
}
 
template<typename type_t, typename allocator_t = std::allocator<type_t>>
inline auto operator <<(std::ostream& os, const std::list<type_t, allocator_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, values.begin(), values.end());
}
 
template<typename type_t>
inline auto operator <<(std::ostream& os, const std::valarray<type_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, std::begin(values), std::end(values));
}
 
template<typename type_t, typename allocator_t = std::allocator<type_t>>
inline auto operator <<(std::ostream& os, const std::vector<type_t, allocator_t>& values) -> std::ostream& {
  return __xtd_console_print_sequence_container(os, values.begin(), values.end());
}
 
template<typename iterator_t>
inline auto __xtd_console_print_associative_container(std::ostream& os, const iterator_t& begin, const iterator_t& end) -> std::ostream& {
  os << "{";
  __xtd_console_print_container(os, begin, end);
  return os << "}";
}
 
template<typename key_t, typename value_t, typename compare_t = std::less <key_t>, typename allocator_t = std::allocator<std::pair<const key_t, value_t>>>
inline auto operator <<(std::ostream& os, const std::map < key_t, value_t, compare_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template<typename key_t, typename value_t, typename compare_t = std::less <key_t>, typename allocator_t = std::allocator<std::pair<const key_t, value_t>>>
inline auto operator <<(std::ostream& os, const std::multimap < key_t, value_t, compare_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template<typename key_t, typename compare_t = std::less <key_t>, typename allocator_t = std::allocator<key_t>>
inline auto operator <<(std::ostream& os, const std::multiset < key_t, compare_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template < class key_t, typename compare_t = std::less < key_t>, typename allocator_t = std::allocator<key_t >>
inline auto operator <<(std::ostream& os, const std::set < key_t, compare_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template < class key_t, typename value_t, typename pred_t = std::equal_to < key_t>, typename allocator_t = std::allocator<std::pair<const key_t, value_t >>>
inline auto operator <<(std::ostream& os, const std::unordered_map < key_t, value_t, pred_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template < class key_t, typename value_t, typename pred_t = std::equal_to < key_t>, typename allocator_t = std::allocator<std::pair<const key_t, value_t >>>
inline auto operator <<(std::ostream& os, const std::unordered_multimap < key_t, value_t, pred_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template < class key_t, typename pred_t = std::equal_to < key_t>, typename allocator_t = std::allocator<key_t >>
auto operator <<(std::ostream& os, const std::unordered_multiset < key_t, pred_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
template < class key_t, typename pred_t = std::equal_to < key_t>, typename allocator_t = std::allocator<key_t >>
inline auto operator <<(std::ostream& os, const std::unordered_set < key_t, pred_t, allocator_t >& values) -> std::ostream& {
  return __xtd_console_print_associative_container(os, values.begin(), values.end());
}
 
inline auto operator <<(std::ostream& os, const std::error_category& value) -> std::ostream& {
  return os << "(" << value.name() << ")";
}
 
inline auto operator <<(std::ostream& os, const std::error_code& value) -> std::ostream& {
  return os << "(value = " << value.value() << "category= " << value.category().name() << ")";
}
 
namespace xtd {
  class iformatable;
  template<typename type_t>
  class istringable;
}
 
auto operator << (std::ostream& os, const xtd::iformatable& value) -> std::ostream&;
 
template<typename type_t>
auto operator << (std::ostream& os, const xtd::istringable<type_t>& value) noexcept -> std::ostream& {
  return os << value.to_string();
}