1//===- FormatVariadicDetails.h - Helpers for FormatVariadic.h ----*- C++-*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_SUPPORT_FORMATVARIADICDETAILS_H
10#define LLVM_SUPPORT_FORMATVARIADICDETAILS_H
11
12#include "llvm/ADT/StringRef.h"
13#include "llvm/Support/raw_ostream.h"
14
15#include <type_traits>
16
17namespace llvm {
18template <typename T, typename Enable = void> struct format_provider {};
19class Error;
20
21namespace detail {
22class format_adapter {
23 virtual void anchor();
24
25protected:
26 virtual ~format_adapter() {}
27
28public:
29 virtual void format(raw_ostream &S, StringRef Options) = 0;
30};
31
32template <typename T> class provider_format_adapter : public format_adapter {
33 T Item;
34
35public:
36 explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
37
38 void format(llvm::raw_ostream &S, StringRef Options) override {
39 format_provider<std::decay_t<T>>::format(Item, S, Options);
40 }
41};
42
43template <typename T>
44class stream_operator_format_adapter : public format_adapter {
45 T Item;
46
47public:
48 explicit stream_operator_format_adapter(T &&Item)
49 : Item(std::forward<T>(Item)) {}
50
51 void format(llvm::raw_ostream &S, StringRef) override { S << Item; }
52};
53
54template <typename T> class missing_format_adapter;
55
56// Test if format_provider<T> is defined on T and contains a member function
57// with the signature:
58// static void format(const T&, raw_stream &, StringRef);
59//
60template <class T> class has_FormatProvider {
61public:
62 using Decayed = std::decay_t<T>;
63 typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
64 StringRef);
65
66 template <typename U>
67 static char test(SameType<Signature_format, &U::format> *);
68
69 template <typename U> static double test(...);
70
71 static bool const value =
72 (sizeof(test<llvm::format_provider<Decayed>>(nullptr)) == 1);
73};
74
75// Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
76template <class T> class has_StreamOperator {
77public:
78 using ConstRefT = const std::decay_t<T> &;
79
80 template <typename U>
81 static char test(
82 std::enable_if_t<std::is_same<decltype(std::declval<llvm::raw_ostream &>()
83 << std::declval<U>()),
84 llvm::raw_ostream &>::value,
85 int *>);
86
87 template <typename U> static double test(...);
88
89 static bool const value = (sizeof(test<ConstRefT>(nullptr)) == 1);
90};
91
92// Simple template that decides whether a type T should use the member-function
93// based format() invocation.
94template <typename T>
95struct uses_format_member
96 : public std::integral_constant<
97 bool,
98 std::is_base_of<format_adapter, std::remove_reference_t<T>>::value> {
99};
100
101// Simple template that decides whether a type T should use the format_provider
102// based format() invocation. The member function takes priority, so this test
103// will only be true if there is not ALSO a format member.
104template <typename T>
105struct uses_format_provider
106 : public std::integral_constant<
107 bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
108};
109
110// Simple template that decides whether a type T should use the operator<<
111// based format() invocation. This takes last priority.
112template <typename T>
113struct uses_stream_operator
114 : public std::integral_constant<bool, !uses_format_member<T>::value &&
115 !uses_format_provider<T>::value &&
116 has_StreamOperator<T>::value> {};
117
118// Simple template that decides whether a type T has neither a member-function
119// nor format_provider based implementation that it can use. Mostly used so
120// that the compiler spits out a nice diagnostic when a type with no format
121// implementation can be located.
122template <typename T>
123struct uses_missing_provider
124 : public std::integral_constant<bool, !uses_format_member<T>::value &&
125 !uses_format_provider<T>::value &&
126 !uses_stream_operator<T>::value> {
127};
128
129template <typename T>
130std::enable_if_t<uses_format_member<T>::value, T>
131build_format_adapter(T &&Item) {
132 return std::forward<T>(Item);
133}
134
135template <typename T>
136std::enable_if_t<uses_format_provider<T>::value, provider_format_adapter<T>>
137build_format_adapter(T &&Item) {
138 return provider_format_adapter<T>(std::forward<T>(Item));
139}
140
141template <typename T>
142std::enable_if_t<uses_stream_operator<T>::value,
143 stream_operator_format_adapter<T>>
144build_format_adapter(T &&Item) {
145 // If the caller passed an Error by value, then stream_operator_format_adapter
146 // would be responsible for consuming it.
147 // Make the caller opt into this by calling fmt_consume().
148 static_assert(
149 !std::is_same<llvm::Error, std::remove_cv_t<T>>::value,
150 "llvm::Error-by-value must be wrapped in fmt_consume() for formatv");
151 return stream_operator_format_adapter<T>(std::forward<T>(Item));
152}
153
154template <typename T>
155std::enable_if_t<uses_missing_provider<T>::value, missing_format_adapter<T>>
156build_format_adapter(T &&) {
157 return missing_format_adapter<T>();
158}
159}
160}
161
162#endif
163