Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-07 21:59:54 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/AK/GenericShorthands.h

88 lines
2.7 KiB
C
Raw Normal View History

AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
/*
* Copyright (c) 2022, Frhun <serenitystuff@frhun.de>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 12:18:30 +01:00
#include <AK/Platform.h>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
#include <AK/StdLibExtras.h>
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 12:18:30 +01:00
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
namespace AK {
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_one_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... || (forward<T>(to_compare) == forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_smaller_than_one_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... || (forward<T>(to_compare) < forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_smaller_or_equal_than_one_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... || (forward<T>(to_compare) <= forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_larger_than_one_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... || (forward<T>(to_compare) > forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_larger_or_equal_than_one_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... || (forward<T>(to_compare) >= forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
AK: Add `first_is_equal_to_all_of()` This method returns true if all arguments are equal.
2025-03-18 12:46:51 +00:00
template<typename T, typename... Ts>
[[nodiscard]] constexpr bool first_is_equal_to_all_of(T&& to_compare, Ts&&... valid_values)
{
return (... && (forward<T>(to_compare) == forward<Ts>(valid_values)));
}
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_smaller_than_all_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... && (forward<T>(to_compare) < forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_smaller_or_equal_than_all_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... && (forward<T>(to_compare) <= forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_larger_than_all_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... && (forward<T>(to_compare) > forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
template<typename T, typename... Ts>
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
[[nodiscard]] constexpr bool first_is_larger_or_equal_than_all_of(T&& to_compare, Ts&&... valid_values)
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
{
AK: Optimize performance in GenericShorthands via forwarding references Functions in AK/GenericShorthands used pass-by-value which results in copying values when calling those functions. This could be expensive for complex types. To optimize performance, we switch the functions to use forwarding references.
2025-01-07 16:23:23 +01:00
return (... && (forward<T>(to_compare) >= forward<Ts>(valid_values)));
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
Meta: Enforce newlines around namespaces This has come up several times during code review, so let's just enforce it using a new clang-format 20 option.
2025-05-13 07:06:33 -04:00
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
}
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 12:18:30 +01:00
#if USING_AK_GLOBALLY
AK: Add `first_is_equal_to_all_of()` This method returns true if all arguments are equal.
2025-03-18 12:46:51 +00:00
using AK::first_is_equal_to_all_of;
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-04 05:29:46 +02:00
using AK::first_is_larger_or_equal_than_all_of;
using AK::first_is_larger_or_equal_than_one_of;
using AK::first_is_larger_than_all_of;
using AK::first_is_larger_than_one_of;
using AK::first_is_one_of;
using AK::first_is_smaller_or_equal_than_all_of;
using AK::first_is_smaller_or_equal_than_one_of;
using AK::first_is_smaller_than_all_of;
using AK::first_is_smaller_than_one_of;
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 12:18:30 +01:00
#endif
Reference in a new issue Copy permalink