libcxx/include/format

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_FORMAT
  11 #define _LIBCPP_FORMAT
  12
  13 /*
  14
  15 namespace std {
  16   // [format.context], class template basic_format_context
  17   template<class Out, class charT> class basic_format_context;
  18   using format_context = basic_format_context<unspecified, char>;
  19   using wformat_context = basic_format_context<unspecified, wchar_t>;
  20
  21   // [format.args], class template basic_format_args
  22   template<class Context> class basic_format_args;
  23   using format_args = basic_format_args<format_context>;
  24   using wformat_args = basic_format_args<wformat_context>;
  25
  26   // [format.fmt.string], class template basic_format_string
  27   template<class charT, class... Args>
  28     struct basic_format_string {                                // since C++23, exposition only before C++23
  29     private:
  30       basic_string_view<charT> str;                             // exposition only
  31
  32     public:
  33       template<class T> consteval basic_format_string(const T& s);
  34       basic_format_string(runtime-format-string<charT> s) noexcept : str(s.str) {}   // since C++26
  35
  36       constexpr basic_string_view<charT> get() const noexcept { return str; }
  37     };
  38   template<class... Args>
  39     using format_string =                                       // since C++23, exposition only before C++23
  40       basic_format_string<char, type_identity_t<Args>...>;
  41   template<class... Args>
  42     using wformat_string =                                      // since C++23, exposition only before C++23
  43       basic_format_string<wchar_t, type_identity_t<Args>...>;
  44
  45   template<class charT> struct runtime-format-string {          // since C++26, exposition-only
  46   private:
  47     basic_string_view<charT> str;                               // exposition-only
  48
  49   public:
  50     runtime-format-string(basic_string_view<charT> s) noexcept : str(s) {}
  51
  52     runtime-format-string(const runtime-format-string&) = delete;
  53     runtime-format-string& operator=(const runtime-format-string&) = delete;
  54   };
  55
  56   runtime-format-string<char> runtime_format(string_view fmt) noexcept {
  57     return fmt;
  58   }
  59   runtime-format-string<wchar_t> runtime_format(wstring_view fmt) noexcept {
  60     return fmt;
  61   }
  62
  63   // [format.functions], formatting functions
  64   template<class... Args>
  65     string format(format-string<Args...> fmt, Args&&... args);
  66   template<class... Args>
  67     wstring format(wformat-string<Args...> fmt, Args&&... args);
  68   template<class... Args>
  69     string format(const locale& loc, format-string<Args...> fmt, Args&&... args);
  70   template<class... Args>
  71     wstring format(const locale& loc, wformat-string<Args...> fmt, Args&&... args);
  72
  73   string vformat(string_view fmt, format_args args);
  74   wstring vformat(wstring_view fmt, wformat_args args);
  75   string vformat(const locale& loc, string_view fmt, format_args args);
  76   wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);
  77
  78   template<class Out, class... Args>
  79     Out format_to(Out out, format-string<Args...> fmt, Args&&... args);
  80   template<class Out, class... Args>
  81     Out format_to(Out out, wformat-string<Args...> fmt, Args&&... args);
  82   template<class Out, class... Args>
  83     Out format_to(Out out, const locale& loc, format-string<Args...> fmt, Args&&... args);
  84   template<class Out, class... Args>
  85     Out format_to(Out out, const locale& loc, wformat-string<Args...> fmt, Args&&... args);
  86
  87   template<class Out>
  88     Out vformat_to(Out out, string_view fmt, format_args args);
  89   template<class Out>
  90     Out vformat_to(Out out, wstring_view fmt, wformat_args args);
  91   template<class Out>
  92     Out vformat_to(Out out, const locale& loc, string_view fmt,
  93                    format_args char> args);
  94   template<class Out>
  95     Out vformat_to(Out out, const locale& loc, wstring_view fmt,
  96                    wformat_args args);
  97
  98   template<class Out> struct format_to_n_result {
  99     Out out;
 100     iter_difference_t<Out> size;
 101   };
 102   template<class Out, class... Args>
 103     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 104                                         format-string<Args...> fmt, Args&&... args);
 105   template<class Out, class... Args>
 106     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 107                                         wformat-string<Args...> fmt, Args&&... args);
 108   template<class Out, class... Args>
 109     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 110                                         const locale& loc, format-string<Args...> fmt,
 111                                         Args&&... args);
 112   template<class Out, class... Args>
 113     format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 114                                         const locale& loc, wformat-string<Args...> fmt,
 115                                         Args&&... args);
 116
 117   template<class... Args>
 118     size_t formatted_size(format-string<Args...> fmt, Args&&... args);
 119   template<class... Args>
 120     size_t formatted_size(wformat-string<Args...> fmt, Args&&... args);
 121   template<class... Args>
 122     size_t formatted_size(const locale& loc, format-string<Args...> fmt, Args&&... args);
 123   template<class... Args>
 124     size_t formatted_size(const locale& loc, wformat-string<Args...> fmt, Args&&... args);
 125
 126   // [format.formatter], formatter
 127   template<class T, class charT = char> struct formatter;
 128
 129   template<class T>
 130   constexpr bool enable_nonlocking_formatter_optimization = false;   // since C++23
 131
 132   // [format.parse.ctx], class template basic_format_parse_context
 133   template<class charT> class basic_format_parse_context;
 134   using format_parse_context = basic_format_parse_context<char>;
 135   using wformat_parse_context = basic_format_parse_context<wchar_t>;
 136
 137   // [format.range], formatting of ranges
 138   // [format.range.fmtkind], variable template format_kind
 139   enum class range_format {                                          // since C++23
 140     disabled,
 141     map,
 142     set,
 143     sequence,
 144     string,
 145     debug_string
 146   };
 147
 148   template<class R>
 149     constexpr unspecified format_kind = unspecified;                 // since C++23
 150
 151   template<ranges::input_range R>
 152       requires same_as<R, remove_cvref_t<R>>
 153     constexpr range_format format_kind<R> = see below;               // since C++23
 154
 155   // [format.range.formatter], class template range_formatter
 156   template<class T, class charT = char>
 157     requires same_as<remove_cvref_t<T>, T> && formattable<T, charT>
 158   class range_formatter;                                             // since C++23
 159
 160   // [format.range.fmtdef], class template range-default-formatter
 161   template<range_format K, ranges::input_range R, class charT>
 162     struct range-default-formatter;                                  // exposition only, since C++23
 163
 164   // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr],
 165   // specializations for maps, sets, and strings
 166   template<ranges::input_range R, class charT>
 167     requires (format_kind<R> != range_format::disabled) &&
 168              formattable<ranges::range_reference_t<R>, charT>
 169   struct formatter<R, charT> : range-default-formatter<format_kind<R>, R, charT> { }; // since C++23
 170
 171   // [format.arguments], arguments
 172   // [format.arg], class template basic_format_arg
 173   template<class Context> class basic_format_arg;
 174
 175   template<class Visitor, class Context>
 176     see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg); // Deprecated in C++26
 177
 178   // [format.arg.store], class template format-arg-store
 179   template<class Context, class... Args> struct format-arg-store;    // exposition only
 180
 181   template<class Context = format_context, class... Args>
 182     format-arg-store<Context, Args...>
 183       make_format_args(Args&... args);
 184   template<class... Args>
 185     format-arg-store<wformat_context, Args...>
 186       make_wformat_args(Args&... args);
 187
 188   // [format.error], class format_error
 189   class format_error;
 190 }
 191
 192 */
 193
 194 #include <__config>
 195
 196 #if _LIBCPP_STD_VER >= 20
 197 #  include <__format/buffer.h>
 198 #  include <__format/concepts.h>
 199 #  include <__format/container_adaptor.h>
 200 #  include <__format/enable_insertable.h>
 201 #  include <__format/escaped_output_table.h>
 202 #  include <__format/extended_grapheme_cluster_table.h>
 203 #  include <__format/format_arg.h>
 204 #  include <__format/format_arg_store.h>
 205 #  include <__format/format_args.h>
 206 #  include <__format/format_context.h>
 207 #  include <__format/format_error.h>
 208 #  include <__format/format_functions.h>
 209 #  include <__format/format_parse_context.h>
 210 #  include <__format/format_string.h>
 211 #  include <__format/format_to_n_result.h>
 212 #  include <__format/formatter.h>
 213 #  include <__format/formatter_bool.h>
 214 #  include <__format/formatter_char.h>
 215 #  include <__format/formatter_floating_point.h>
 216 #  include <__format/formatter_integer.h>
 217 #  include <__format/formatter_pointer.h>
 218 #  include <__format/formatter_string.h>
 219 #  include <__format/formatter_tuple.h>
 220 #  include <__format/parser_std_format_spec.h>
 221 #  include <__format/range_default_formatter.h>
 222 #  include <__format/range_formatter.h>
 223 #  include <__format/unicode.h>
 224 #  include <__fwd/format.h>
 225 #endif
 226
 227 #include <version>
 228
 229 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 230 #  pragma GCC system_header
 231 #endif
 232
 233 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 234 #  include <array>
 235 #  include <cctype>
 236 #  include <cerrno>
 237 #  include <clocale>
 238 #  include <cmath>
 239 #  include <cstddef>
 240 #  include <cstdint>
 241 #  include <cstdlib>
 242 #  include <cstring>
 243 #  include <initializer_list>
 244 #  include <limits>
 245 #  include <locale>
 246 #  include <new>
 247 #  include <optional>
 248 #  include <queue>
 249 #  include <stack>
 250 #  include <stdexcept>
 251 #  include <string>
 252 #  include <string_view>
 253 #  include <tuple>
 254
 255 #  if _LIBCPP_HAS_WIDE_CHARACTERS
 256 #    include <cwchar>
 257 #  endif
 258 #endif
 259
 260 #endif // _LIBCPP_FORMAT