1 // Formatting library for C++ - the core API
2 //
3 // Copyright (c) 2012 - present, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7 //
8 // Copyright (c) 2018 - present, Remotion (Igor Schulz)
9 // All Rights Reserved
10 // {fmt} support for ranges, containers and types tuple interface.
11
12 #ifndef FMT_RANGES_H_
13 #define FMT_RANGES_H_
14
15 #include "format.h"
16 #include <type_traits>
17
18 // output only up to N items from the range.
19 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
20 # define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
21 #endif
22
23 FMT_BEGIN_NAMESPACE
24
25 template <typename Char>
26 struct formatting_base {
27 template <typename ParseContext>
28 FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
29 return ctx.begin();
30 }
31 };
32
33 template <typename Char, typename Enable = void>
34 struct formatting_range : formatting_base<Char> {
35 static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
36 FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
37 Char prefix;
38 Char delimiter;
39 Char postfix;
formatting_rangeformatting_range40 formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
41 static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
42 static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
43 };
44
45 template <typename Char, typename Enable = void>
46 struct formatting_tuple : formatting_base<Char> {
47 Char prefix;
48 Char delimiter;
49 Char postfix;
formatting_tupleformatting_tuple50 formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
51 static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
52 static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
53 };
54
55 namespace internal {
56
57 template <typename RangeT, typename OutputIterator>
copy(const RangeT & range,OutputIterator out)58 void copy(const RangeT &range, OutputIterator out) {
59 for (auto it = range.begin(), end = range.end(); it != end; ++it)
60 *out++ = *it;
61 }
62
63 template <typename OutputIterator>
copy(const char * str,OutputIterator out)64 void copy(const char *str, OutputIterator out) {
65 const char *p_curr = str;
66 while (*p_curr) {
67 *out++ = *p_curr++;
68 }
69 }
70
71 template <typename OutputIterator>
copy(char ch,OutputIterator out)72 void copy(char ch, OutputIterator out) {
73 *out++ = ch;
74 }
75
76 /// Return true value if T has std::string interface, like std::string_view.
77 template <typename T>
78 class is_like_std_string {
79 template <typename U>
80 static auto check(U *p) ->
81 decltype(p->find('a'), p->length(), p->data(), int());
82 template <typename>
83 static void check(...);
84
85 public:
86 static FMT_CONSTEXPR_DECL const bool value =
87 !std::is_void<decltype(check<T>(FMT_NULL))>::value;
88 };
89
90 template <typename Char>
91 struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
92
93 template <typename... Ts>
94 struct conditional_helper {};
95
96 template <typename T, typename _ = void>
97 struct is_range_ : std::false_type {};
98
99 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
100 template <typename T>
101 struct is_range_<T, typename std::conditional<
102 false,
103 conditional_helper<decltype(internal::declval<T>().begin()),
104 decltype(internal::declval<T>().end())>,
105 void>::type> : std::true_type {};
106 #endif
107
108 /// tuple_size and tuple_element check.
109 template <typename T>
110 class is_tuple_like_ {
111 template <typename U>
112 static auto check(U *p) ->
113 decltype(std::tuple_size<U>::value,
114 internal::declval<typename std::tuple_element<0, U>::type>(), int());
115 template <typename>
116 static void check(...);
117
118 public:
119 static FMT_CONSTEXPR_DECL const bool value =
120 !std::is_void<decltype(check<T>(FMT_NULL))>::value;
121 };
122
123 // Check for integer_sequence
124 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
125 template <typename T, T... N>
126 using integer_sequence = std::integer_sequence<T, N...>;
127 template <std::size_t... N>
128 using index_sequence = std::index_sequence<N...>;
129 template <std::size_t N>
130 using make_index_sequence = std::make_index_sequence<N>;
131 #else
132 template <typename T, T... N>
133 struct integer_sequence {
134 typedef T value_type;
135
136 static FMT_CONSTEXPR std::size_t size() {
137 return sizeof...(N);
138 }
139 };
140
141 template <std::size_t... N>
142 using index_sequence = integer_sequence<std::size_t, N...>;
143
144 template <typename T, std::size_t N, T... Ns>
145 struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
146 template <typename T, T... Ns>
147 struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
148
149 template <std::size_t N>
150 using make_index_sequence = make_integer_sequence<std::size_t, N>;
151 #endif
152
153 template <class Tuple, class F, size_t... Is>
154 void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
155 using std::get;
156 // using free function get<I>(T) now.
157 const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
158 (void)_; // blocks warnings
159 }
160
161 template <class T>
162 FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value>
163 get_indexes(T const &) { return {}; }
164
165 template <class Tuple, class F>
166 void for_each(Tuple &&tup, F &&f) {
167 const auto indexes = get_indexes(tup);
168 for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
169 }
170
171 template<typename Arg>
172 FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&,
173 typename std::enable_if<
174 !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
175 return add_space ? " {}" : "{}";
176 }
177
178 template<typename Arg>
179 FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&,
180 typename std::enable_if<
181 is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
182 return add_space ? " \"{}\"" : "\"{}\"";
183 }
184
185 FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
186 return add_space ? " \"{}\"" : "\"{}\"";
187 }
188 FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
189 return add_space ? L" \"{}\"" : L"\"{}\"";
190 }
191
192 FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
193 return add_space ? " '{}'" : "'{}'";
194 }
195 FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
196 return add_space ? L" '{}'" : L"'{}'";
197 }
198
199 } // namespace internal
200
201 template <typename T>
202 struct is_tuple_like {
203 static FMT_CONSTEXPR_DECL const bool value =
204 internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
205 };
206
207 template <typename TupleT, typename Char>
208 struct formatter<TupleT, Char,
209 typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
210 private:
211 // C++11 generic lambda for format()
212 template <typename FormatContext>
213 struct format_each {
214 template <typename T>
215 void operator()(const T& v) {
216 if (i > 0) {
217 if (formatting.add_prepostfix_space) {
218 *out++ = ' ';
219 }
220 internal::copy(formatting.delimiter, out);
221 }
222 format_to(out,
223 internal::format_str_quoted(
224 (formatting.add_delimiter_spaces && i > 0), v),
225 v);
226 ++i;
227 }
228
229 formatting_tuple<Char>& formatting;
230 std::size_t& i;
231 typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
232 };
233
234 public:
235 formatting_tuple<Char> formatting;
236
237 template <typename ParseContext>
238 FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
239 return formatting.parse(ctx);
240 }
241
242 template <typename FormatContext = format_context>
243 auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
244 auto out = ctx.out();
245 std::size_t i = 0;
246 internal::copy(formatting.prefix, out);
247
248 internal::for_each(values, format_each<FormatContext>{formatting, i, out});
249 if (formatting.add_prepostfix_space) {
250 *out++ = ' ';
251 }
252 internal::copy(formatting.postfix, out);
253
254 return ctx.out();
255 }
256 };
257
258 template <typename T>
259 struct is_range {
260 static FMT_CONSTEXPR_DECL const bool value =
261 internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
262 };
263
264 template <typename RangeT, typename Char>
265 struct formatter<RangeT, Char,
266 typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
267
268 formatting_range<Char> formatting;
269
270 template <typename ParseContext>
271 FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
272 return formatting.parse(ctx);
273 }
274
275 template <typename FormatContext>
276 typename FormatContext::iterator format(
277 const RangeT &values, FormatContext &ctx) {
278 auto out = ctx.out();
279 internal::copy(formatting.prefix, out);
280 std::size_t i = 0;
281 for (auto it = values.begin(), end = values.end(); it != end; ++it) {
282 if (i > 0) {
283 if (formatting.add_prepostfix_space) {
284 *out++ = ' ';
285 }
286 internal::copy(formatting.delimiter, out);
287 }
288 format_to(out,
289 internal::format_str_quoted(
290 (formatting.add_delimiter_spaces && i > 0), *it),
291 *it);
292 if (++i > formatting.range_length_limit) {
293 format_to(out, " ... <other elements>");
294 break;
295 }
296 }
297 if (formatting.add_prepostfix_space) {
298 *out++ = ' ';
299 }
300 internal::copy(formatting.postfix, out);
301 return ctx.out();
302 }
303 };
304
305 FMT_END_NAMESPACE
306
307 #endif // FMT_RANGES_H_
308
309