mirror/magic_enum
1
0
Fork 0
mirror of https://github.com/Neargye/magic_enum.git synced 2026-01-09 23:34:23 +00:00
Code Activity

add enum_flags_test and enum_flags_test_any functions for flags (#277)

Browse source 
Co-authored-by: Jon Petrissans <jon.petrissans@protonmail.com>
This commit is contained in:
Daniil Goncharov 2023-06-05 14:10:02 +04:00 • committed by GitHub
parent 0b2c1cf072
commit 9508c563da
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 105 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

59
include/magic_enum_flags.hpp Normal file
View file

@ -0,0 +1,59 @@
// __ __ _ ______ _____
// | \/ | (_) | ____| / ____|_ _
// | \ / | __ _ __ _ _ ___ | |__ _ __ _ _ _ __ ___ | | _| |_ _| |_
// | |\/| |/ _` |/ _` | |/ __| | __| | '_ \| | | | '_ ` _ \ | | |_ _|_ _|
// | | | | (_| | (_| | | (__ | |____| | | | |_| | | | | | | | |____|_| |_|
// |_| |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_| \_____|
// __/ | https://github.com/Neargye/magic_enum
// |___/ version 0.9.1
//
// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
// SPDX-License-Identifier: MIT
// Copyright (c) 2019 - 2023 Daniil Goncharov <neargye@gmail.com>.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#ifndef NEARGYE_MAGIC_ENUM_FLAGS_HPP
#define NEARGYE_MAGIC_ENUM_FLAGS_HPP
#include "magic_enum.hpp"
namespace magic_enum {
// Checks whether `flags set` contains `flag`.
// Note: If `flag` equals 0, it returns false, as 0 is not a flag.
template <typename E>
constexpr auto enum_flags_test(E flags, E flag) noexcept -> detail::enable_if_t<E, bool> {
using U = underlying_type_t<E>;
return static_cast<bool>(static_cast<U>(flags) & static_cast<U>(flag));
}
// Checks whether `lhs flags set` and `rhs flags set` have common flags.
// Note: If `lhs flags set` or `rhs flags set` equals 0, it returns false, as 0 is not a flag, and therfore cannot have any matching flag.
template <typename E>
constexpr auto enum_flags_test_any(E lhs, E rhs) noexcept -> detail::enable_if_t<E, bool> {
using U = underlying_type_t<E>;
return (static_cast<U>(lhs) & static_cast<U>(rhs)) != 0;
}
} // namespace magic_enum
#endif // NEARGYE_MAGIC_ENUM_FLAGS_HPP

46
test/test_flags.cpp
View file

@ -33,6 +33,7 @@
#include <catch2/catch.hpp>
#include <magic_enum.hpp>
#include <magic_enum_flags.hpp>
#include <magic_enum_fuse.hpp>
#include <magic_enum_iostream.hpp>
@ -48,6 +49,7 @@ struct magic_enum::customize::enum_range<Color> {
};
enum class Numbers : int {
none = 0,
one = 1 << 1,
two = 1 << 2,
three = 1 << 3,
@ -59,6 +61,7 @@ struct magic_enum::customize::enum_range<Numbers> {
};
enum Directions : std::uint64_t {
NoDirection = 0,
Left = std::uint64_t{1} << 10,
Down = std::uint64_t{1} << 20,
Up = std::uint64_t{1} << 31,
@ -70,6 +73,7 @@ struct magic_enum::customize::enum_range<Directions> {
};
enum number : unsigned long {
no_number = 0,
one = 1 << 1,
two = 1 << 2,
three = 1 << 3,
@ -722,3 +726,45 @@ TEST_CASE("format-base") {
}
#endif
TEST_CASE("enum_flags_test") {
REQUIRE(enum_flags_test(Color::RED|Color::GREEN, Color::RED));
REQUIRE_FALSE(enum_flags_test(Color::RED|Color::GREEN, Color::BLUE));
REQUIRE_FALSE(enum_flags_test(Numbers::none, Numbers::none));
REQUIRE_FALSE(enum_flags_test(Numbers::none, Numbers::one));
REQUIRE(enum_flags_test(Numbers::one|Numbers::two|Numbers::many, Numbers::many));
REQUIRE_FALSE(enum_flags_test(Numbers::one|Numbers::two|Numbers::many, Numbers::three));
REQUIRE_FALSE(enum_flags_test(Numbers::one|Numbers::two|Numbers::many, Numbers::none));
REQUIRE_FALSE(enum_flags_test(Left|Right, NoDirection));
REQUIRE(enum_flags_test(Left|Right|Up|Down, Right));
REQUIRE_FALSE(enum_flags_test(Left|Up|Down, Right));
REQUIRE(enum_flags_test(number::one|number::two|number::four, number::one));
REQUIRE_FALSE(enum_flags_test(number::one|number::two|number::four, number::three));
REQUIRE_FALSE(enum_flags_test(number::one|number::two|number::four, number::no_number));
}
TEST_CASE("enum_flags_test_any") {
REQUIRE(enum_flags_test_any(Color::RED|Color::GREEN, Color::RED));
REQUIRE_FALSE(enum_flags_test_any(Color::RED|Color::GREEN, Color::BLUE));
REQUIRE_FALSE(enum_flags_test_any(Numbers::none, Numbers::none));
REQUIRE_FALSE(enum_flags_test_any(Numbers::none, Numbers::one));
REQUIRE(enum_flags_test_any(Numbers::one|Numbers::two|Numbers::many, Numbers::many));
REQUIRE_FALSE(enum_flags_test_any(Numbers::one|Numbers::two|Numbers::many, Numbers::three));
REQUIRE_FALSE(enum_flags_test_any(Numbers::one|Numbers::two|Numbers::many, Numbers::none));
REQUIRE_FALSE(enum_flags_test_any(Left|Right, NoDirection));
REQUIRE(enum_flags_test_any(Left|Right|Up|Down, Right));
REQUIRE_FALSE(enum_flags_test_any(Left|Up|Down, Right));
REQUIRE(enum_flags_test_any(number::one|number::two|number::four, number::one));
REQUIRE_FALSE(enum_flags_test_any(number::one|number::two|number::four, number::three));
REQUIRE_FALSE(enum_flags_test_any(number::one|number::two|number::four, number::no_number));
REQUIRE(enum_flags_test(Numbers::none, Numbers::none) == enum_flags_test_any(Numbers::none, Numbers::none));
REQUIRE(enum_flags_test(Numbers::one, Numbers::none) == enum_flags_test_any(Numbers::one, Numbers::none));
REQUIRE(enum_flags_test(Numbers::none, Numbers::one) == enum_flags_test_any(Numbers::none, Numbers::one));
}