header_utils
Loading...
Searching...
No Matches
assuming.h
1
4
5#pragma once
6
7#include <version>
8#include <cassert>
9
10#if !defined(__cpp_lib_format)
11#error "This library requires std::format"
12#endif
13#include "source_location.h"
14
32
35
37#ifndef ASSUMING_DEBUG
38#ifdef NDEBUG
39#define ASSUMING_DEBUG 0
40#else
41#define ASSUMING_DEBUG 1
42#endif
43#endif
44
46#ifndef ASSUMING_INCLUDE_MAGIC_ENUM
47#if __has_include(<magic_enum.hpp>)
48#define ASSUMING_INCLUDE_MAGIC_ENUM 1
49#else
50#define ASSUMING_INCLUDE_MAGIC_ENUM 0
51#endif
52#endif
53
54#include <format>
55#include "source_location.h"
56#if ASSUMING_DEBUG
57#include <sstream>
58#endif
59
60#if ASSUMING_INCLUDE_MAGIC_ENUM
61#include <magic_enum.hpp>
62#endif
63
64#ifdef __has_cpp_attribute
65#if __has_cpp_attribute(assume)
67#define GHPL_CPP23_ASSUME(...) [[assume(__VA_ARGS__)]];
68#endif
69#endif
70#ifndef GHPL_CPP23_ASSUME
71#define GHPL_CPP23_ASSUME(...)
72#endif
73
74#if !ASSUMING_DEBUG
75#ifdef _MSC_VER
76#define ASSUMING_ASSUME(cond) GHPL_CPP23_ASSUME(cond) (__assume(cond), (::std::ignore = (cond)))
77#elif defined(__GNUC__)
78#define ASSUMING_ASSUME(cond) GHPL_CPP23_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
79#else
80#define ASSUMING_ASSUME(cond) GHPL_CPP23_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
81#endif
82#endif
83
84#if ASSUMING_DEBUG || defined(DOXYGEN)
85
87#define Assuming(exp, ...) { if (auto&& _assuming_exp_v = (exp); !_assuming_exp_v) [[unlikely]] \
88 ::ghassanpl::ReportAssumptionFailure(#exp " will evalute to true", { { #exp, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_exp_v)) } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
89
91#define AssumingNotReachable(...) { ::ghassanpl::ReportAssumptionFailure("execution will never reach this point", {}, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
92
94#define AssumingNotRecursive(...) \
95 static int _assuming_recursion_counter##__LINE__ = 0; \
96 if (_assuming_recursion_counter##__LINE__ != 0) \
97 ::ghassanpl::ReportAssumptionFailure("enclosing block will not be entered recursively", {}, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); \
98 const ::ghassanpl::detail::RecursionScopeMarker _assuming_scope_marker##__LINE__( _assuming_recursion_counter##__LINE__ )
99
101#define AssumingSingleThread(...) { \
102 static std::thread::id _assuming_thread_id = std::this_thread::get_id(); \
103 auto _assuming_current_thread_id = std::this_thread::get_id(); \
104 if (_assuming_thread_id != _assuming_current_thread_id)\
105 ::ghassanpl::ReportAssumptionFailure("this code will be executed in one thread only", { {"required_thread_id", std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_thread_id))}, {"thread_id", std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_current_thread_id))} }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); \
106 }
107
109#define AssumingOnThread(thread_to_check, ...) { \
110 auto _assuming_thread_id = (thread_to_check); \
111 auto _assuming_current_thread_id = std::this_thread::get_id(); \
112 if (_assuming_thread_id != _assuming_current_thread_id)\
113 ::ghassanpl::ReportAssumptionFailure("this code will be executed in one thread only", { {"required_thread_id", std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_thread_id))}, { "thread_id", std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_current_thread_id))} }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); \
114 }
115
117#define AssumingNotOnThread(thread_to_check, ...) { \
118 auto _assuming_thread_id = (thread_to_check); \
119 auto _assuming_current_thread_id = std::this_thread::get_id(); \
120 if (_assuming_thread_id == _assuming_current_thread_id)\
121 ::ghassanpl::ReportAssumptionFailure("this code will not be executed in specific thread", { {"forbidden_thread_id", std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_thread_id))}, { "thread_id", std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_current_thread_id))} }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); \
122 }
123
125#define AssumingNull(exp, ...) { if (auto _assuming_exp_v = (const void*)std::to_address(exp); _assuming_exp_v != nullptr) [[unlikely]] \
126 ::ghassanpl::ReportAssumptionFailure(#exp " will be null", { { #exp, std::format("{}", _assuming_exp_v) } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
127
129#define AssumingNotNull(exp, ...) { if (auto _assuming_exp_v = (const void*)std::to_address(exp); _assuming_exp_v == nullptr) [[unlikely]] \
130 ::ghassanpl::ReportAssumptionFailure(#exp " will not be null", { { #exp, std::format("{}", _assuming_exp_v) } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
131
133#define AssumingBinOp(a, b, op, text, ...) { auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); if (!(_assuming_a_v op _assuming_b_v)) [[unlikely]] \
134 ::ghassanpl::ReportAssumptionFailure(#a " will " text " " #b, { \
135 { #a, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_a_v)) }, \
136 { #b, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_b_v)) } \
137 }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
138
140#define AssumingEqual(a, b, ...) AssumingBinOp(a, b, ==, "be equal to", __VA_ARGS__)
142#define AssumingNotEqual(a, b, ...) AssumingBinOp(a, b, !=, "not be equal to", __VA_ARGS__)
144#define AssumingGreater(a, b, ...) AssumingBinOp(a, b, >, "be greater than", __VA_ARGS__)
146#define AssumingLess(a, b, ...) AssumingBinOp(a, b, <, "be less than", __VA_ARGS__)
148#define AssumingGreaterEqual(a, b, ...) AssumingBinOp(a, b, >=, "be greater or equal to", __VA_ARGS__)
150#define AssumingLessEqual(a, b, ...) AssumingBinOp(a, b, <=, "be less or equal to", __VA_ARGS__)
151
153#define AssumingContainsBits(a, b, ...) { auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); if (!((_assuming_a_v & _assuming_b_v) == _assuming_b_v)) [[unlikely]] \
154 ::ghassanpl::ReportAssumptionFailure(#a " will contain flags " #b, { \
155 { #a, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_a_v)) }, \
156 { #b, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_b_v)) } \
157 }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
158
160#define AssumingZero(a, ...) AssumingBinOp(a, 0, ==, "be equal to", __VA_ARGS__)
161
163#define AssumingEmpty(exp, ...) { using std::empty; using std::size; if (auto&& _assuming_exp_v = (exp); !empty(_assuming_exp_v)) [[unlikely]] \
164 ::ghassanpl::ReportAssumptionFailure(#exp " will be empty", { { "size of " #exp, std::format("{}", size(_assuming_exp_v)) } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
165
167#define AssumingNotEmpty(exp, ...) { using std::empty; using std::size; if (auto&& _assuming_exp_v = (exp); empty(_assuming_exp_v)) [[unlikely]] \
168 ::ghassanpl::ReportAssumptionFailure(#exp " will not be empty", { { "size of " #exp, std::format("{}", size(_assuming_exp_v)) } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
169
171#define AssumingNullOrEmpty(exp, ...) { using std::empty; using std::size; if (auto&& _assuming_exp_v = (exp); !::ghassanpl::detail::IsNullOrEmpty(_assuming_exp_v)) [[unlikely]] \
172 ::ghassanpl::ReportAssumptionFailure(#exp " will be null or empty", { { #exp, _assuming_exp_v ? std::format("'{}'", _assuming_exp_v) : "(null)" } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
173
175#define AssumingNotNullOrEmpty(exp, ...) { using std::empty; using std::size; if (auto&& _assuming_exp_v = (exp); ::ghassanpl::detail::IsNullOrEmpty(_assuming_exp_v)) [[unlikely]] \
176 ::ghassanpl::ReportAssumptionFailure(#exp " will not be null or empty", { { #exp, _assuming_exp_v ? std::format("'{}'", _assuming_exp_v) : "(null)" } }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
177
179#define AssumingValidIndex(_index, _container, ...) { using std::size; auto&& _assuming_index = (_index); auto&& _assuming_container = (_container); const auto _assuming_container_size = size(_assuming_container); \
180 if (!(_assuming_index >= 0 && size_t(_assuming_index) < _assuming_container_size)) [[unlikely]] { \
181 ::ghassanpl::ReportAssumptionFailure(#_index " will be a valid index to " #_container, { \
182 { #_index, std::format("{}", _assuming_index) }, \
183 { "size of " #_container, std::format("{}", _assuming_container_size) }, \
184 }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); } }
185
187#define AssumingValidIterator(_iterator, _container, ...) { using std::end; auto&& _assuming_iterator = (_iterator); auto&& _assuming_container = (_container); const auto _assuming_end = end(_assuming_container); \
188 if (_assuming_iterator == _assuming_end) [[unlikely]] { \
189 ::ghassanpl::ReportAssumptionFailure(#_iterator " will be a valid iterator to " #_container, {}, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); } }
190
192#define AssumingBetween(v, a, b, ...) { auto&& _assuming_v_v = (v); auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); if (!(_assuming_v_v >= _assuming_a_v && _assuming_v_v < _assuming_b_v)) [[unlikely]] \
193 ::ghassanpl::ReportAssumptionFailure(#v " will be between " #a " and " #b, { \
194 { #v, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_v_v)) }, \
195 { #a, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_a_v)) }, \
196 { #b, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_b_v)) } \
197 }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
198
200#define AssumingBetweenInclusive(v, a, b, ...) { auto&& _assuming_v_v = (v); auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); if (!(_assuming_v_v >= _assuming_a_v && _assuming_v_v <= _assuming_b_v)) [[unlikely]] \
201 ::ghassanpl::ReportAssumptionFailure(#v " will be between " #a " and " #b " (inclusive)", { \
202 { #v, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_v_v)) }, \
203 { #a, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_a_v)) }, \
204 { #b, std::format("{}", ::ghassanpl::detail::GetFormattable(_assuming_b_v)) } \
205 }, ::ghassanpl::detail::AdditionalDataToString(__VA_ARGS__)); }
206#else
207
208#define Assuming(exp, ...) ASSUMING_ASSUME(!!(exp))
209#define AssumingNotReachable(...) ASSUMING_ASSUME(false)
210
211// NOTE: TODO: The three macros below have a significant codegen overhead, should we even try their assumptions? I don't think the compiler can infer any useful information from them...
212#define AssumingNotRecursive(...) \
213 static int _assuming_recursion_counter##__LINE__ = 0; \
214 ASSUMING_ASSUME(_assuming_recursion_counter##__LINE__ == 0); \
215 const ::ghassanpl::detail::RecursionScopeMarker _assuming_scope_marker##__LINE__( _assuming_recursion_counter##__LINE__ )
216#define AssumingSingleThread(...) { \
217 static std::thread::id _assuming_thread_id = std::this_thread::get_id(); \
218 auto _assuming_current_thread_id = std::this_thread::get_id(); \
219 ASSUMING_ASSUME(_assuming_thread_id == _assuming_current_thread_id); \
220 }
221#define AssumingOnThread(thread_to_check, ...) { \
222 auto _assuming_thread_id = (thread_to_check); \
223 auto _assuming_current_thread_id = std::this_thread::get_id(); \
224 ASSUMING_ASSUME(_assuming_thread_id == _assuming_current_thread_id); \
225 }
226
227
228#define AssumingNull(exp, ...) ASSUMING_ASSUME(!((exp) != nullptr))
229#define AssumingNotNull(exp, ...) ASSUMING_ASSUME(!((exp) == nullptr))
230#define AssumingBinOp(a, b, op, text, ...) ASSUMING_ASSUME(((a) op (b)))
231#define AssumingEqual(a, b, ...) AssumingBinOp(a, b, ==, "be equal to", __VA_ARGS__)
232#define AssumingZero(a, ...) AssumingBinOp(a, 0, ==, "be equal to", __VA_ARGS__)
233#define AssumingNotEqual(a, b, ...) AssumingBinOp(a, b, !=, "not be equal to", __VA_ARGS__)
234#define AssumingGreater(a, b, ...) AssumingBinOp(a, b, >, "be greater than", __VA_ARGS__)
235#define AssumingLess(a, b, ...) AssumingBinOp(a, b, <, "be less than", __VA_ARGS__)
236#define AssumingGreaterEqual(a, b, ...) AssumingBinOp(a, b, >=, "be greater or equal to", __VA_ARGS__)
237#define AssumingLessEqual(a, b, ...) AssumingBinOp(a, b, <=, "be less or equal to", __VA_ARGS__)
238#define AssumingEmpty(exp, ...) { using std::empty; ASSUMING_ASSUME(empty(exp)); }
239#define AssumingNotEmpty(exp, ...) { using std::empty; using std::size; ASSUMING_ASSUME(!empty(exp)); }
240#define AssumingNullOrEmpty(exp, ...) { using std::empty; using std::size; ASSUMING_ASSUME(::ghassanpl::detail::IsNullOrEmpty(exp)); }
241#define AssumingNotNullOrEmpty(exp, ...) { using std::empty; using std::size; ASSUMING_ASSUME(!::ghassanpl::detail::IsNullOrEmpty(exp)); }
242#define AssumingValidIndex(_index, _container, ...) { using std::size; auto&& _assuming_index = (_index); ASSUMING_ASSUME(((_assuming_index) >= 0 && size_t(_assuming_index) < size(_container))); }
243#define AssumingValidIterator(_iterator, _container, ...) { using std::end; auto&& _assuming_iterator = (_iterator); auto&& _assuming_container = (_container); const auto _assuming_end = end(_assuming_container); ASSUMING_ASSUME(!(_assuming_iterator == _assuming_end)); }
244#define AssumingBetween(v, a, b, ...) { auto&& _assuming_v_v = (v); auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); ASSUMING_ASSUME(_assuming_v_v >= _assuming_a_v && _assuming_v_v < _assuming_b_v); }
245#define AssumingBetweenInclusive(v, a, b, ...) { auto&& _assuming_v_v = (v); auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); ASSUMING_ASSUME(_assuming_v_v >= _assuming_a_v && _assuming_v_v <= _assuming_b_v); }
246
247#define AssumingContainsBits(a, b, ...) { auto&& _assuming_a_v = (a); auto&& _assuming_b_v = (b); ASSUMING_ASSUME(!((_assuming_a_v & _assuming_b_v) == _assuming_b_v)); }
248
249
250#endif
251
253
254namespace ghassanpl
255{
256 namespace detail
257 {
258 inline bool IsNullOrEmpty(const char* str) { return str == nullptr || str[0] == 0; }
259 template <typename T>
260 inline bool IsNullOrEmpty(T&& str) { using std::empty; return empty(str); }
261
262#if ASSUMING_DEBUG
263 /*
264 template <typename T>
265 concept formattable = requires { typename std::formatter<T>; };
266 */
267
268 template <typename T>
269 concept formattable = requires { { std::formatter<T>{} }; };
270
271 template <typename T>
272 concept streamable = requires (T val, std::stringstream & ss) { { ss << val }; };
273
274 template <typename T>
275 decltype(auto) GetFormattable(T&& val)
276 {
277 using simple_type = std::remove_cvref_t<T>;
278#if ASSUMING_INCLUDE_MAGIC_ENUM
279 if constexpr (std::is_enum_v<simple_type>)
280 return magic_enum::enum_name(val);
281 else
282#endif
283 if constexpr (std::is_constructible_v<std::string_view, simple_type>)
284 return std::forward<T>(val);
285 else if constexpr (std::is_pointer_v<simple_type>)
286 return (const void*)std::to_address(std::forward<T>(val));
287 else if constexpr (streamable<simple_type> && !formattable<simple_type>)
288 {
289 std::stringstream ss;
290 ss << std::forward<T>(val);
291 return std::move(ss).str();
292 }
293 else if constexpr (!formattable<simple_type> && !streamable<simple_type>)
294 return std::format("<{}>", typeid(simple_type).name());
295 else
296 return std::forward<T>(val);
297 }
298
299 inline std::string AdditionalDataToString() { return {}; }
300 template <typename T, typename... ARGS>
301 std::string AdditionalDataToString(T&& fmt, ARGS&&... args) {
302 return std::vformat(std::forward<T>(fmt), std::make_format_args(GetFormattable(std::forward<ARGS>(args))...));
303 }
304
306 struct RecursionScopeMarker
307 {
308 explicit RecursionScopeMarker(int& counter) : mCounter(counter) { ++mCounter; }
309 ~RecursionScopeMarker() { --mCounter; }
310 int& mCounter;
311 };
312
313
314#endif
315 }
316
317 inline void DefaultReportAssumptionFailure(std::string_view expectation, std::initializer_list<std::pair<std::string_view, std::string>> values, std::string data, source_location loc)
318 {
319 throw std::make_tuple(
320 std::move(expectation),
321 std::move(values),
322 std::move(data),
323 std::move(loc)
324 );
325 }
326
333 inline void (*AssumptionFailureHandler)(std::string_view expectation, std::initializer_list<std::pair<std::string_view, std::string>> values, std::string data, source_location loc) = nullptr;
334
335#if defined(ASSUMING_REPORT_NORETURN) && ASSUMING_REPORT_NORETURN
336 [[noreturn]]
337#endif
338 inline void ReportAssumptionFailure(std::string_view expectation, std::initializer_list<std::pair<std::string_view, std::string>> values, std::string data, source_location loc
339#if __INTELLISENSE__
340 = {}
341#else
342 = source_location::current()
343#endif
344 )
345 {
346 if (AssumptionFailureHandler)
347 AssumptionFailureHandler(std::move(expectation), std::move(values), std::move(data), std::move(loc));
348 else
349 DefaultReportAssumptionFailure(std::move(expectation), std::move(values), std::move(data), std::move(loc));
350 }
351}
352
355
359
ghassanpl::AssumptionFailureHandler
void(* AssumptionFailureHandler)(std::string_view expectation, std::initializer_list< std::pair< std::string_view, std::string > > values, std::string data, source_location loc)
This function must be provided by your own code, as it is called by an assumption macro with a failin...
Definition assuming.h:333
ghassanpl::bit_count
constexpr auto bit_count
Equal to the number of bits in the type.
Definition bits.h:33
detail
The below code is based on Sun's libm library code, which is licensed under the following license:
Definition constexpr_math.inl:12
ghassanpl
Primary namespace for everything in this library.
Definition align+rec2.h:10