LLVM 20.0.0git
FormatVariadicDetails.h
Go to the documentation of this file.
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/ADT/STLExtras.h"
15
16#include <type_traits>
17
18namespace llvm {
19template <typename T, typename Enable = void> struct format_provider {};
20class Error;
21
22namespace support {
23namespace detail {
25 virtual void anchor();
26
27protected:
28 virtual ~format_adapter() = default;
29
30public:
31 virtual void format(raw_ostream &S, StringRef Options) = 0;
32};
33
34template <typename T> class provider_format_adapter : public format_adapter {
35 T Item;
36
37public:
38 explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
39
42 }
43};
44
45template <typename T>
47 T Item;
48
49public:
51 : Item(std::forward<T>(Item)) {}
52
53 void format(llvm::raw_ostream &S, StringRef) override { S << Item; }
54};
55
56template <typename T> class missing_format_adapter;
57
58// Test if format_provider<T> is defined on T and contains a member function
59// with the signature:
60// static void format(const T&, raw_stream &, StringRef);
61//
62template <class T> class has_FormatProvider {
63public:
64 using Decayed = std::decay_t<T>;
65 typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
66 StringRef);
67
68 template <typename U>
70
71 template <typename U> static double test(...);
72
73 static bool const value =
74 (sizeof(test<llvm::format_provider<Decayed>>(nullptr)) == 1);
75};
76
77// Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
78template <class T> class has_StreamOperator {
79public:
80 using ConstRefT = const std::decay_t<T> &;
81
82 template <typename U>
83 static char test(std::enable_if_t<
84 std::is_same_v<decltype(std::declval<llvm::raw_ostream &>()
85 << std::declval<U>()),
87 int *>);
88
89 template <typename U> static double test(...);
90
91 static bool const value = (sizeof(test<ConstRefT>(nullptr)) == 1);
92};
93
94// Simple template that decides whether a type T should use the member-function
95// based format() invocation.
96template <typename T>
98 : public std::integral_constant<
99 bool, std::is_base_of_v<format_adapter, std::remove_reference_t<T>>> {
100};
101
102// Simple template that decides whether a type T should use the format_provider
103// based format() invocation. The member function takes priority, so this test
104// will only be true if there is not ALSO a format member.
105template <typename T>
107 : public std::integral_constant<
108 bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
109};
110
111// Simple template that decides whether a type T should use the operator<<
112// based format() invocation. This takes last priority.
113template <typename T>
115 : public std::integral_constant<bool, !uses_format_member<T>::value &&
116 !uses_format_provider<T>::value &&
117 has_StreamOperator<T>::value> {};
118
119// Simple template that decides whether a type T has neither a member-function
120// nor format_provider based implementation that it can use. Mostly used so
121// that the compiler spits out a nice diagnostic when a type with no format
122// implementation can be located.
123template <typename T>
125 : public std::integral_constant<bool, !uses_format_member<T>::value &&
126 !uses_format_provider<T>::value &&
127 !uses_stream_operator<T>::value> {
128};
129
130template <typename T>
131std::enable_if_t<uses_format_member<T>::value, T>
133 return std::forward<T>(Item);
134}
135
136template <typename T>
137std::enable_if_t<uses_format_provider<T>::value, provider_format_adapter<T>>
139 return provider_format_adapter<T>(std::forward<T>(Item));
140}
141
142template <typename T>
143std::enable_if_t<uses_stream_operator<T>::value,
144 stream_operator_format_adapter<T>>
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_v<llvm::Error, std::remove_cv_t<T>>,
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
155template <typename T>
156std::enable_if_t<uses_missing_provider<T>::value, missing_format_adapter<T>>
159}
160} // namespace detail
161} // namespace support
162} // namespace llvm
163
164#endif
static LVOptions Options
Definition: LVOptions.cpp:25
This file contains some templates that are useful if you are working with the STL at all.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
virtual void format(raw_ostream &S, StringRef Options)=0
void(* Signature_format)(const Decayed &, llvm::raw_ostream &, StringRef)
static char test(SameType< Signature_format, &U::format > *)
static char test(std::enable_if_t< std::is_same_v< decltype(std::declval< llvm::raw_ostream & >()<< std::declval< U >()), llvm::raw_ostream & >, int * >)
void format(llvm::raw_ostream &S, StringRef Options) override
void format(llvm::raw_ostream &S, StringRef) override
std::enable_if_t< uses_format_member< T >::value, T > build_format_adapter(T &&Item)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858