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_FORMATVARIADIC_DETAILS_H
10 #define LLVM_SUPPORT_FORMATVARIADIC_DETAILS_H
11 
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/Support/raw_ostream.h"
14 
15 #include <type_traits>
16 
17 namespace llvm {
18 template <typename T, typename Enable = void> struct format_provider {};
19 class Error;
20 
21 namespace detail {
22 class format_adapter {
23   virtual void anchor();
24 
25 protected:
26   virtual ~format_adapter() {}
27 
28 public:
29   virtual void format(raw_ostream &S, StringRef Options) = 0;
30 };
31 
32 template <typename T> class provider_format_adapter : public format_adapter {
33   T Item;
34 
35 public:
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<typename std::decay<T>::type>::format(Item, S, Options);
40   }
41 };
42 
43 template <typename T>
44 class stream_operator_format_adapter : public format_adapter {
45   T Item;
46 
47 public:
48   explicit stream_operator_format_adapter(T &&Item)
49       : Item(std::forward<T>(Item)) {}
50 
51   void format(llvm::raw_ostream &S, StringRef Options) override { S << Item; }
52 };
53 
54 template <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 //
60 template <class T> class has_FormatProvider {
61 public:
62   using Decayed = typename std::decay<T>::type;
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.
76 template <class T> class has_StreamOperator {
77 public:
78   using ConstRefT = const typename std::decay<T>::type &;
79 
80   template <typename U>
81   static char test(typename std::enable_if<
82                    std::is_same<decltype(std::declval<llvm::raw_ostream &>()
83                                          << std::declval<U>()),
84                                 llvm::raw_ostream &>::value,
85                    int *>::type);
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.
94 template <typename T>
95 struct uses_format_member
96     : public std::integral_constant<
97           bool,
98           std::is_base_of<format_adapter,
99                           typename std::remove_reference<T>::type>::value> {};
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.
104 template <typename T>
105 struct 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.
112 template <typename T>
113 struct 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.
122 template <typename T>
123 struct 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 
129 template <typename T>
130 typename std::enable_if<uses_format_member<T>::value, T>::type
131 build_format_adapter(T &&Item) {
132   return std::forward<T>(Item);
133 }
134 
135 template <typename T>
136 typename std::enable_if<uses_format_provider<T>::value,
137                         provider_format_adapter<T>>::type
138 build_format_adapter(T &&Item) {
139   return provider_format_adapter<T>(std::forward<T>(Item));
140 }
141 
142 template <typename T>
143 typename std::enable_if<uses_stream_operator<T>::value,
144                         stream_operator_format_adapter<T>>::type
145 build_format_adapter(T &&Item) {
146   // If the caller passed an Error by value, then stream_operator_format_adapter
147   // would be responsible for consuming it.
148   // Make the caller opt into this by calling fmt_consume().
149   static_assert(
150       !std::is_same<llvm::Error, typename std::remove_cv<T>::type>::value,
151       "llvm::Error-by-value must be wrapped in fmt_consume() for formatv");
152   return stream_operator_format_adapter<T>(std::forward<T>(Item));
153 }
154 
155 template <typename T>
156 typename std::enable_if<uses_missing_provider<T>::value,
157                         missing_format_adapter<T>>::type
158 build_format_adapter(T &&Item) {
159   return missing_format_adapter<T>();
160 }
161 }
162 }
163 
164 #endif
165