mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-22 17:24:48 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/AK/GenericShorthands.h

80 lines
2.5 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-03 23:29:46 -04: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 06:18:30 -05: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 10:23:23 -05: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 06:18:30 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 10:23:23 -05: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-03 23:29:46 -04: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 06:18:30 -05:00
#if USING_AK_GLOBALLY
AK: Add header for generic shorthands These are functions that can be expressed with just normal operators, but would be very repetetive.
2022-07-03 23:29:46 -04: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 06:18:30 -05:00
#endif
Reference in a new issue Copy permalink