rocprofiler-sdk/cxx/details/mpl.hpp Source File

rocprofiler-sdk/cxx/details/mpl.hpp Source File#

ROCprofiler-SDK developer API: rocprofiler-sdk/cxx/details/mpl.hpp Source File
ROCprofiler-SDK developer API 1.4.1
ROCm Profiling API and tools
mpl.hpp
1// MIT License
2//
3// Copyright (c) 2023-2025 Advanced Micro Devices, Inc. All rights reserved.
4//
5// Permission is hereby granted, free of charge, to any person obtaining a copy
6// of this software and associated documentation files (the "Software"), to deal
7// in the Software without restriction, including without limitation the rights
8// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9// copies of the Software, and to permit persons to whom the Software is
10// furnished to do so, subject to the following conditions:
11//
12// The above copyright notice and this permission notice shall be included in all
13// copies or substantial portions of the Software.
14//
15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21// SOFTWARE.
22//
23
24#pragma once
25
26#include <cstddef>
27#include <cstdint>
28#include <optional>
29#include <string>
30#include <string_view>
31#include <type_traits>
32#include <utility>
33
34#define ROCPROFILER_IMPL_HAS_CONCEPT(NAME, TRAIT) \
35 template <typename Tp, typename = typename Tp::TRAIT> \
36 inline constexpr bool NAME(int) \
37 { \
38 return true; \
39 } \
40 \
41 template <typename Tp> \
42 inline constexpr bool NAME(long) \
43 { \
44 return false; \
45 }
46
47#define ROCPROFILER_IMPL_SFINAE_CONCEPT(NAME, ...) \
48 template <typename Tp> \
49 struct NAME \
50 { \
51 private: \
52 static constexpr auto sfinae(int) -> decltype(__VA_ARGS__, bool()) { return true; } \
53 \
54 static constexpr auto sfinae(long) { return false; } \
55 \
56 public: \
57 static constexpr bool value = sfinae(0); \
58 constexpr auto operator()() const { return sfinae(0); } \
59 };
60
61namespace rocprofiler
62{
63namespace sdk
64{
65namespace mpl
66{
67template <typename Tp>
68struct unqualified_identity
69{
70 using type = std::remove_cv_t<std::remove_reference_t<std::decay_t<Tp>>>;
71};
72
73template <typename Tp>
74using unqualified_identity_t = typename unqualified_identity<Tp>::type;
75
76template <typename Tp, typename Up>
77struct is_same_unqualified_identity
78: std::is_same<unqualified_identity_t<Tp>, unqualified_identity_t<Up>>
79{};
80
81template <typename Tp>
82struct string_support
83{
84 using type = Tp;
85 using return_type = void;
86
87 static constexpr auto value = false;
88 static constexpr void default_value() {}
89};
90
91template <>
92struct string_support<const char*>
93{
94 using type = const char*;
95 using return_type = type;
96
97 static constexpr auto value = true;
98 static constexpr type default_value() { return nullptr; }
99
100 type operator()(const char* val) const { return val; }
101};
102
103template <>
104struct string_support<std::string_view>
105{
106 using type = std::string_view;
107 using return_type = type;
108
109 static constexpr auto value = true;
110 static constexpr type default_value() { return type{}; }
111
112 type operator()(const char* val) const { return type{val}; }
113};
114
115template <>
116struct string_support<std::string>
117{
118 using type = std::string;
119 using return_type = type;
120
121 static constexpr auto value = true;
122 static type default_value() { return type{}; }
123
124 type operator()(const char* val) const { return type{val}; }
125};
126
127namespace impl
128{
129template <typename Tp>
130struct is_string_type : std::false_type
131{};
132
133template <>
134struct is_string_type<std::string> : std::true_type
135{};
136
137template <>
138struct is_string_type<char*> : std::true_type
139{};
140
141template <>
142struct is_string_type<const char*> : std::true_type
143{};
144
145template <>
146struct is_string_type<std::string_view> : std::true_type
147{};
148
149template <typename Tp>
150struct is_optional : std::false_type
151{};
152
153template <typename Tp>
154struct is_optional<std::optional<Tp>> : std::true_type
155{};
156} // namespace impl
157
158template <typename Tp>
159struct is_string_type : impl::is_string_type<unqualified_identity_t<Tp>>
160{};
161
162template <typename Tp>
163struct is_optional : impl::is_optional<unqualified_identity_t<Tp>>
164{};
165
166// template <typename Tp>
167// struct can_stringify
168// {
169// private:
170// static constexpr auto sfinae(int)
171// -> decltype(std::declval<std::ostream&>() << std::declval<Tp>(), bool())
172// {
173// return true;
174// }
175
176// static constexpr auto sfinae(long) { return false; }
177
178// public:
179// static constexpr bool value = sfinae(0);
180// constexpr auto operator()() const { return sfinae(0); }
181// };
182
183ROCPROFILER_IMPL_HAS_CONCEPT(has_traits, traits_type)
184ROCPROFILER_IMPL_HAS_CONCEPT(has_value_type, value_type)
185ROCPROFILER_IMPL_HAS_CONCEPT(has_key_type, key_type)
186ROCPROFILER_IMPL_HAS_CONCEPT(has_mapped_type, mapped_type)
187
188ROCPROFILER_IMPL_SFINAE_CONCEPT(has_empty_member_function, std::declval<Tp>().empty())
189ROCPROFILER_IMPL_SFINAE_CONCEPT(can_stringify, std::declval<std::ostream&>() << std::declval<Tp>())
190ROCPROFILER_IMPL_SFINAE_CONCEPT(is_iterable,
191 std::begin(std::declval<Tp>()),
192 std::end(std::declval<Tp>()))
193
194// compatibility
195template <typename Tp>
196using supports_ostream = can_stringify<Tp>;
197
198template <typename ArgT>
199inline bool
200is_empty(ArgT&& _v)
201{
202 using arg_type = unqualified_identity_t<ArgT>;
203
204 if constexpr(has_empty_member_function<arg_type>::value)
205 {
206 return std::forward<ArgT>(_v).empty();
207 }
208 else if constexpr(is_string_type<arg_type>::value)
209 {
210 static_assert(std::is_constructible<std::string_view, ArgT>::value,
211 "not string_view constructible");
212 return std::string_view{std::forward<ArgT>(_v)}.empty();
213 }
214
215 return false;
216}
217
218namespace impl
219{
220template <typename ContainerT, typename... Args>
221inline auto
222emplace(ContainerT& _c, int, Args&&... _args)
223 -> decltype(_c.emplace_back(std::forward<Args>(_args)...))
224{
225 return _c.emplace_back(std::forward<Args>(_args)...);
226}
227
228template <typename ContainerT, typename... Args>
229inline auto
230emplace(ContainerT& _c, long, Args&&... _args) -> decltype(_c.emplace(std::forward<Args>(_args)...))
231{
232 return _c.emplace(std::forward<Args>(_args)...);
233}
234
235template <typename ContainerT, typename ArgT>
236inline auto
237reserve(ContainerT& _c, int, ArgT _arg) -> decltype(_c.reserve(_arg), bool())
238{
239 _c.reserve(_arg);
240 return true;
241}
242
243template <typename ContainerT, typename ArgT>
244inline auto
245reserve(ContainerT&, long, ArgT)
246{
247 return false;
248}
249} // namespace impl
250
251template <typename ContainerT, typename... Args>
252inline auto
253emplace(ContainerT& _c, Args&&... _args)
254{
255 return impl::emplace(_c, 0, std::forward<Args>(_args)...);
256}
257
258template <typename ContainerT, typename ArgT>
259inline auto
260reserve(ContainerT& _c, ArgT _arg)
261{
262 return impl::reserve(_c, 0, _arg);
263}
264
265template <typename Tp>
266struct assert_false
267{
268 static constexpr auto value = false;
269};
270} // namespace mpl
271} // namespace sdk
272} // namespace rocprofiler
273
274#undef ROCPROFILER_IMPL_HAS_CONCEPT
275#undef ROCPROFILER_IMPL_SFINAE_CONCEPT
std
STL namespace.
Generated by doxygen 1.9.8