src/vendor/fmt/ostream.h

   1 // Formatting library for C++ - std::ostream support
   2 //
   3 // Copyright (c) 2012 - present, Victor Zverovich
   4 // All rights reserved.
   5 //
   6 // For the license information refer to format.h.
   7
   8 #ifndef FMT_OSTREAM_H_
   9 #define FMT_OSTREAM_H_
  10
  11 #include <fstream>
  12 #include <ostream>
  13 #if defined(_WIN32) && defined(__GLIBCXX__)
  14 #  include <ext/stdio_filebuf.h>
  15 #  include <ext/stdio_sync_filebuf.h>
  16 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
  17 #  include <__std_stream>
  18 #endif
  19
  20 #include "format.h"
  21
  22 FMT_BEGIN_NAMESPACE
  23
  24 template <typename OutputIt, typename Char> class basic_printf_context;
  25
  26 namespace detail {
  27
  28 // Checks if T has a user-defined operator<<.
  29 template <typename T, typename Char, typename Enable = void>
  30 class is_streamable {
  31  private:
  32   template <typename U>
  33   static auto test(int)
  34       -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
  35                               << std::declval<U>()) != 0>;
  36
  37   template <typename> static auto test(...) -> std::false_type;
  38
  39   using result = decltype(test<T>(0));
  40
  41  public:
  42   is_streamable() = default;
  43
  44   static const bool value = result::value;
  45 };
  46
  47 // Formatting of built-in types and arrays is intentionally disabled because
  48 // it's handled by standard (non-ostream) formatters.
  49 template <typename T, typename Char>
  50 struct is_streamable<
  51     T, Char,
  52     enable_if_t<
  53         std::is_arithmetic<T>::value || std::is_array<T>::value ||
  54         std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
  55         std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
  56         std::is_same<T, std_string_view<Char>>::value ||
  57         (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
  58     : std::false_type {};
  59
  60 // Generate a unique explicit instantion in every translation unit using a tag
  61 // type in an anonymous namespace.
  62 namespace {
  63 struct file_access_tag {};
  64 }  // namespace
  65 template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
  66 class file_access {
  67   friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
  68 };
  69
  70 #if FMT_MSC_VERSION
  71 template class file_access<file_access_tag, std::filebuf,
  72                            &std::filebuf::_Myfile>;
  73 auto get_file(std::filebuf&) -> FILE*;
  74 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
  75 template class file_access<file_access_tag, std::__stdoutbuf<char>,
  76                            &std::__stdoutbuf<char>::__file_>;
  77 auto get_file(std::__stdoutbuf<char>&) -> FILE*;
  78 #endif
  79
  80 inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
  81 #if FMT_MSC_VERSION
  82   if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
  83     if (FILE* f = get_file(*buf)) return write_console(f, data);
  84 #elif defined(_WIN32) && defined(__GLIBCXX__)
  85   auto* rdbuf = os.rdbuf();
  86   FILE* c_file;
  87   if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
  88     c_file = fbuf->file();
  89   else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
  90     c_file = fbuf->file();
  91   else
  92     return false;
  93   if (c_file) return write_console(c_file, data);
  94 #elif defined(_WIN32) && defined(_LIBCPP_VERSION)
  95   if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
  96     if (FILE* f = get_file(*buf)) return write_console(f, data);
  97 #else
  98   ignore_unused(os, data);
  99 #endif
 100   return false;
 101 }
 102 inline bool write_ostream_unicode(std::wostream&,
 103                                   fmt::basic_string_view<wchar_t>) {
 104   return false;
 105 }
 106
 107 // Write the content of buf to os.
 108 // It is a separate function rather than a part of vprint to simplify testing.
 109 template <typename Char>
 110 void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
 111   const Char* buf_data = buf.data();
 112   using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
 113   unsigned_streamsize size = buf.size();
 114   unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
 115   do {
 116     unsigned_streamsize n = size <= max_size ? size : max_size;
 117     os.write(buf_data, static_cast<std::streamsize>(n));
 118     buf_data += n;
 119     size -= n;
 120   } while (size != 0);
 121 }
 122
 123 template <typename Char, typename T>
 124 void format_value(buffer<Char>& buf, const T& value,
 125                   locale_ref loc = locale_ref()) {
 126   auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
 127   auto&& output = std::basic_ostream<Char>(&format_buf);
 128 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
 129   if (loc) output.imbue(loc.get<std::locale>());
 130 #endif
 131   output << value;
 132   output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
 133 }
 134
 135 template <typename T> struct streamed_view { const T& value; };
 136
 137 }  // namespace detail
 138
 139 // Formats an object of type T that has an overloaded ostream operator<<.
 140 template <typename Char>
 141 struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
 142   void set_debug_format() = delete;
 143
 144   template <typename T, typename OutputIt>
 145   auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
 146       -> OutputIt {
 147     auto buffer = basic_memory_buffer<Char>();
 148     format_value(buffer, value, ctx.locale());
 149     return formatter<basic_string_view<Char>, Char>::format(
 150         {buffer.data(), buffer.size()}, ctx);
 151   }
 152 };
 153
 154 using ostream_formatter = basic_ostream_formatter<char>;
 155
 156 template <typename T, typename Char>
 157 struct formatter<detail::streamed_view<T>, Char>
 158     : basic_ostream_formatter<Char> {
 159   template <typename OutputIt>
 160   auto format(detail::streamed_view<T> view,
 161               basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
 162     return basic_ostream_formatter<Char>::format(view.value, ctx);
 163   }
 164 };
 165
 166 /**
 167   \rst
 168   Returns a view that formats `value` via an ostream ``operator<<``.
 169
 170   **Example**::
 171
 172     fmt::print("Current thread id: {}\n",
 173                fmt::streamed(std::this_thread::get_id()));
 174   \endrst
 175  */
 176 template <typename T>
 177 auto streamed(const T& value) -> detail::streamed_view<T> {
 178   return {value};
 179 }
 180
 181 namespace detail {
 182
 183 // Formats an object of type T that has an overloaded ostream operator<<.
 184 template <typename T, typename Char>
 185 struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
 186     : basic_ostream_formatter<Char> {
 187   using basic_ostream_formatter<Char>::format;
 188 };
 189
 190 inline void vprint_directly(std::ostream& os, string_view format_str,
 191                             format_args args) {
 192   auto buffer = memory_buffer();
 193   detail::vformat_to(buffer, format_str, args);
 194   detail::write_buffer(os, buffer);
 195 }
 196
 197 }  // namespace detail
 198
 199 FMT_MODULE_EXPORT template <typename Char>
 200 void vprint(std::basic_ostream<Char>& os,
 201             basic_string_view<type_identity_t<Char>> format_str,
 202             basic_format_args<buffer_context<type_identity_t<Char>>> args) {
 203   auto buffer = basic_memory_buffer<Char>();
 204   detail::vformat_to(buffer, format_str, args);
 205   if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
 206   detail::write_buffer(os, buffer);
 207 }
 208
 209 /**
 210   \rst
 211   Prints formatted data to the stream *os*.
 212
 213   **Example**::
 214
 215     fmt::print(cerr, "Don't {}!", "panic");
 216   \endrst
 217  */
 218 FMT_MODULE_EXPORT template <typename... T>
 219 void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
 220   const auto& vargs = fmt::make_format_args(args...);
 221   if (detail::is_utf8())
 222     vprint(os, fmt, vargs);
 223   else
 224     detail::vprint_directly(os, fmt, vargs);
 225 }
 226
 227 FMT_MODULE_EXPORT
 228 template <typename... Args>
 229 void print(std::wostream& os,
 230            basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
 231            Args&&... args) {
 232   vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
 233 }
 234
 235 FMT_END_NAMESPACE
 236
 237 #endif  // FMT_OSTREAM_H_