fix: update plg includes

Author: qubka

include/plg/allocator.hpp

@@ -143,23 +143,23 @@ namespace plg {
 	// asan_annotate_container_with_allocator determines whether containers with custom allocators are annotated. This is
 	// a public customization point to disable annotations if the custom allocator assumes that the memory isn't poisoned.
 	// See the https://libcxx.llvm.org/UsingLibcxx.html#turning-off-asan-annotation-in-containers for more information.
-#if __has_feature(address_sanitizer)
+#if PLUGIFY_INSTRUMENTED_WITH_ASAN
 	template <class Alloc>
 	struct asan_annotate_container_with_allocator : std::true_type {};
-#endif
+#endif // PLUGIFY_INSTRUMENTED_WITH_ASAN
 
 	// Annotate a contiguous range.
 	// [__first_storage, __last_storage) is the allocated memory region,
 	// __old_last_contained is the previously last allowed (unpoisoned) element, and
 	// __new_last_contained is the new last allowed (unpoisoned) element.
 	template <class Allocator>
-	void annotate_contiguous_container(
+	constexpr void annotate_contiguous_container(
 		[[maybe_unused]] const void* first_storage,
 		[[maybe_unused]] const void* last_storage,
 		[[maybe_unused]] const void* old_last_contained,
 		[[maybe_unused]] const void* new_last_contained
 	) {
-#if __has_feature(address_sanitizer)
+#if PLUGIFY_INSTRUMENTED_WITH_ASAN
 		if (!std::is_constant_evaluated()
 			&& asan_annotate_container_with_allocator<Allocator>::value
 			&& first_storage != nullptr) {
@@ -170,6 +170,6 @@ namespace plg {
 				new_last_contained
 			);
 		}
-#endif
+#endif // PLUGIFY_INSTRUMENTED_WITH_ASAN
 	}
 } // namespace plg

include/plg/concepts.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <concepts>
 #include <memory>
 #include <type_traits>

include/plg/config.hpp

@@ -16,7 +16,7 @@
 #  define __has_builtin(x) 0
 #endif
 
-#ifndef __builtin_constant_p
+#if !__has_builtin(__builtin_constant_p)
 #  define __builtin_constant_p(x) std::is_constant_evaluated()
 #endif
 
@@ -29,11 +29,7 @@
 #  define PLUGIFY_ASSERT(cond, mesg) assert((cond) && (mesg))
 #endif
 
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-#  include <sanitizer/asan_interface.h>
-#endif
-
-#define PLUGIFY_HAS_EXCEPTIONS __cpp_exceptions || _CPPUNWIND || __EXCEPTIONS
+#define PLUGIFY_HAS_EXCEPTIONS  __cpp_exceptions || _CPPUNWIND || __EXCEPTIONS
 #if PLUGIFY_HAS_EXCEPTIONS
 #  include <stdexcept>
 #  include <type_traits>
@@ -47,11 +43,20 @@ namespace plg {
 		}
 	}
 } // namespace plg
-#  define PLUGIFY_THROW(str, exp, ...) ::plg::throw_exception<exp>(str, ##__VA_ARGS__);
+#  define PLUGIFY_THROW(str, exp, ...) ::plg::throw_exception<exp>(str __VA_OPT__(,) __VA_ARGS__);
 #else
 #  include <cstdlib>
 #  include <cstdio>
-#  define PLUGIFY_THROW(str, ...) { std::fputs(str "\n", stderr); std::abort(); }
+#  define PLUGIFY_THROW(str, ...) \
+	std::fputs(str "\n", stderr); \
+	std::abort();
+#endif
+
+#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+#  define PLUGIFY_INSTRUMENTED_WITH_ASAN 1
+#  include <sanitizer/asan_interface.h>
+#else
+#  define PLUGIFY_INSTRUMENTED_WITH_ASAN 0
 #endif
 
 #  define PLUGIFY_COMPILER_MAKE_VERSION2(version, sp)         ((version) * 100 + (sp))

include/plg/enum.hpp

@@ -17,15 +17,15 @@ namespace plg {
 	template <std::size_t N>
 	struct static_string {
 		constexpr static_string(std::string_view sv) noexcept {
-			std::copy(sv.begin(), sv.end(), _content.begin());
+			std::copy(sv.begin(), sv.end(), content_.begin());
 		}
 
 		constexpr operator std::string_view() const noexcept {
-			return { _content.data(), N };
+			return { content_.data(), N };
 		}
 
 	private:
-		std::array<char, N + 1> _content{};
+		std::array<char, N + 1> content_{};
 	};
 
 	constexpr auto is_pretty(char ch) noexcept {

include/plg/guards.hpp

@@ -9,35 +9,35 @@ namespace plg {
 		exception_guard_exceptions() = delete;
 
 		constexpr explicit exception_guard_exceptions(Rollback rollback)
-			: _rollback(std::move(rollback))
-			, _completed(false) {
+			: rollback_(std::move(rollback))
+			, completed_(false) {
 		}
 
 		constexpr exception_guard_exceptions(
 			exception_guard_exceptions&& other
 		) noexcept(std::is_nothrow_move_constructible_v<Rollback>)
-			: _rollback(std::move(other._rollback))
-			, _completed(other._completed) {
-			other._completed = true;
+			: rollback_(std::move(other.rollback_))
+			, completed_(other.completed_) {
+			other.completed_ = true;
 		}
 
 		exception_guard_exceptions(const exception_guard_exceptions&) = delete;
 		exception_guard_exceptions& operator=(const exception_guard_exceptions&) = delete;
 		exception_guard_exceptions& operator=(exception_guard_exceptions&&) = delete;
 
 		constexpr void complete() noexcept {
-			_completed = true;
+			completed_ = true;
 		}
 
 		constexpr ~exception_guard_exceptions() {
-			if (!_completed) {
-				_rollback();
+			if (!completed_) {
+				rollback_();
 			}
 		}
 
 	private:
-		PLUGIFY_NO_UNIQUE_ADDRESS Rollback _rollback;
-		bool _completed;
+		PLUGIFY_NO_UNIQUE_ADDRESS Rollback rollback_;
+		bool completed_;
 	};
 
 	template <class Rollback>
@@ -53,24 +53,24 @@ namespace plg {
 		constexpr exception_guard_noexceptions(
 			exception_guard_noexceptions&& other
 		) noexcept(std::is_nothrow_move_constructible_v<Rollback>)
-			: _completed(other._completed) {
-			other._completed = true;
+			: completed_(other.completed_) {
+			other.completed_ = true;
 		}
 
 		exception_guard_noexceptions(const exception_guard_noexceptions&) = delete;
 		exception_guard_noexceptions& operator=(const exception_guard_noexceptions&) = delete;
 		exception_guard_noexceptions& operator=(exception_guard_noexceptions&&) = delete;
 
 		constexpr void complete() noexcept {
-			_completed = true;
+			completed_ = true;
 		}
 
 		constexpr ~exception_guard_noexceptions() {
-			PLUGIFY_ASSERT(_completed, "exception_guard not completed with exceptions disabled");
+			PLUGIFY_ASSERT(completed_, "exception_guard not completed with exceptions disabled");
 		}
 
 	private:
-		bool _completed = false;
+		bool completed_ = false;
 	};
 
 	template <class Rollback>
@@ -84,15 +84,15 @@ namespace plg {
 
 	template <class Func>
 	class scope_guard {
-		PLUGIFY_NO_UNIQUE_ADDRESS Func _func;
+		PLUGIFY_NO_UNIQUE_ADDRESS Func func_;
 
 	public:
 		constexpr explicit scope_guard(Func func)
-			: _func(std::move(func)) {
+			: func_(std::move(func)) {
 		}
 
 		constexpr ~scope_guard() {
-			_func();
+			func_();
 		}
 
 		scope_guard(const scope_guard&) = delete;

include/plg/hash.hpp

@@ -3,6 +3,8 @@
 #include <filesystem>
 #include <string>
 #include <vector>
+#include <algorithm>
+#include <locale>
 
 #include "plg/string.hpp"
 
@@ -58,11 +60,10 @@ namespace plg {
 		using is_transparent = void;  // Enables heterogeneous lookup
 
 		template <typename T>
-		auto operator()(const T& str_like) const noexcept {
-			std::string_view str = str_like;
+		std::size_t operator()(const T& str) const noexcept {
 			std::size_t hash = active_hash_traits::fnv_basis; // FNV-1a
-			for (const char& c : str) {
-				hash ^= static_cast<unsigned char>(std::tolower(static_cast<unsigned char>(c)));
+			for (const auto& c : str) {
+				hash ^= static_cast<std::size_t>(std::tolower(c));
 				hash *= active_hash_traits::fnv_prime;
 			}
 			return hash;
@@ -73,21 +74,14 @@ namespace plg {
 		using is_transparent = void;  // Enables heterogeneous lookup
 
 		template <typename T1, typename T2>
-		bool operator()(const T1& lhs_like, const T2& rhs_like) const noexcept {
-			std::string_view lhs = lhs_like;
-			std::string_view rhs = rhs_like;
-
-			if (lhs.size() != rhs.size()) {
-				return false;
-			}
-
-			for (size_t i = 0; i < lhs.size(); ++i) {
-				if (std::tolower(static_cast<unsigned char>(lhs[i]))
-				    != std::tolower(static_cast<unsigned char>(rhs[i]))) {
-					return false;
+		bool operator()(const T1& lhs, const T2& rhs) const noexcept {
+			return std::lexicographical_compare(
+				lhs.begin(), lhs.end(),
+				rhs.begin(), rhs.end(),
+				[](const auto& ac, const auto& bc) {
+					return std::tolower(ac) < std::tolower(bc);
 				}
-			}
-			return true;
+			);
 		}
 	};