BlackMATov/enum.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/enum.hpp.git synced 2025-12-16 14:09:03 +07:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'refs/heads/dev'

Browse Source
This commit is contained in:
Matvey Cherevko
2019-11-22 04:21:45 +07:00
parent 0a463746aa 35d63b1b37
commit c95c16d42d
5 changed files with 213 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.travis.yml
View File

@@ -24,10 +24,6 @@ matrix:
after_success: ./scripts/upload_coverage.sh after_success: ./scripts/upload_coverage.sh
before_install: before_install:
- eval "${MATRIX_EVAL}" - eval "${MATRIX_EVAL}"
- if [ "$TRAVIS_OS_NAME" == 'osx' ]; then
brew update;
brew upgrade cmake;
fi
- if [ "$TRAVIS_OS_NAME" == 'linux' ]; then - if [ "$TRAVIS_OS_NAME" == 'linux' ]; then
mkdir $HOME/cmake; mkdir $HOME/cmake;
export PATH="$HOME/cmake/bin:$PATH"; export PATH="$HOME/cmake/bin:$PATH";

90
README.md
View File

@@ -23,6 +23,12 @@
[enum]: https://github.com/BlackMATov/enum.hpp [enum]: https://github.com/BlackMATov/enum.hpp
## Requirements
- [gcc](https://www.gnu.org/software/gcc/) **>= 7**
- [clang](https://clang.llvm.org/) **>= 7.0**
- [msvc](https://visualstudio.microsoft.com/) **>= 2017**
## Installation ## Installation
[enum.hpp][enum] is a header-only library. All you need to do is copy the headers files from `headers` directory into your project and include them: [enum.hpp][enum] is a header-only library. All you need to do is copy the headers files from `headers` directory into your project and include them:
@@ -57,6 +63,7 @@ enum debug_level : int {
}; };
struct debug_level_traits { struct debug_level_traits {
using underlying_type = int;
static constexpr std::size_t size = 3; static constexpr std::size_t size = 3;
static constexpr const debug_level values[] = { static constexpr const debug_level values[] = {
@@ -71,15 +78,13 @@ struct debug_level_traits {
"level_warning" "level_warning"
}; };
static constexpr std::string_view to_string( static constexpr underlying_type to_underlying(debug_level e) noexcept;
debug_level e) noexcept;
static debug_level from_string( static constexpr std::optional<std::string_view> to_string(debug_level e) noexcept;
std::string_view name); static constexpr std::optional<debug_level> from_string(std::string_view name) noexcept;
static constexpr bool from_string_nothrow( static constexpr std::optional<std::size_t> to_index(debug_level e) noexcept;
std::string_view name, static constexpr std::optional<debug_level> from_index(std::size_t index) noexcept;
debug_level& result) noexcept;
}; };
``` ```
@@ -100,6 +105,7 @@ enum class color : unsigned {
}; };
struct color_traits { struct color_traits {
using underlying_type = unsigned;
static constexpr std::size_t size = 4; static constexpr std::size_t size = 4;
static constexpr const color values[] = { static constexpr const color values[] = {
@@ -116,44 +122,56 @@ struct color_traits {
"white" "white"
}; };
static constexpr std::string_view to_string( static constexpr underlying_type to_underlying(color e) noexcept;
color e) noexcept;
static color from_string( static constexpr std::optional<std::string_view> to_string(color e) noexcept;
std::string_view name); static constexpr std::optional<color> from_string(std::string_view name) noexcept;
static constexpr bool from_string_nothrow( static constexpr std::optional<std::size_t> to_index(color e) noexcept;
std::string_view name, static constexpr std::optional<color> from_index(std::size_t index) noexcept;
color& result) noexcept;
}; };
``` ```
### Traits using ### Traits using
```cpp ```cpp
ENUM_HPP_CLASS_DECL(color, unsigned, red, green, blue) namespace
{
// size ENUM_HPP_CLASS_DECL(color, unsigned,
color_traits::size; // 3 (red = 0xFF0000)
(green = 0x00FF00)
// to_string (blue = 0x0000FF)
color_traits::to_string(color::red); // returns "red"; (white = red | green | blue))
color_traits::to_string(color(42)); // returns ""; }
// from_string SECTION("traits_using") {
color_traits::from_string("green"); // returns color::green; // size
color_traits::from_string("error"); // throws enum_hpp::exception STATIC_REQUIRE(color_traits::size == 4);
// from_string_nothrow // to_underlying
color result; STATIC_REQUIRE(color_traits::to_underlying(color::white) == 0xFFFFFF);
bool success = color_traits::from_string_nothrow("blue", result);
// success == true, result == color::blue // to_string
STATIC_REQUIRE(color_traits::to_string(color::red) == "red");
// names STATIC_REQUIRE(color_traits::to_string(color(42)) == std::nullopt);
for ( auto n : color_traits::names ) {
std::cout << n << ","; // from_string
STATIC_REQUIRE(color_traits::from_string("green") == color::green);
STATIC_REQUIRE(color_traits::from_string("error") == std::nullopt);
// to_index
STATIC_REQUIRE(color_traits::to_index(color::blue) == 2);
STATIC_REQUIRE(color_traits::to_index(color(42)) == std::nullopt);
// from_index
STATIC_REQUIRE(color_traits::from_index(2) == color::blue);
STATIC_REQUIRE(color_traits::from_index(42) == std::nullopt);
// names
for ( auto n : color_traits::names ) {
std::cout << n << ",";
} // stdout: red,green,blue,
} }
// prints red,green,blue
``` ```
## Alternatives ## Alternatives

51
headers/enum.hpp/enum.hpp
View File

@@ -6,17 +6,9 @@
#pragma once #pragma once
#include <stdexcept> #include <optional>
#include <string_view> #include <string_view>
#include <type_traits>
namespace enum_hpp
{
class exception final : public std::runtime_error {
public:
explicit exception(const char* what)
: std::runtime_error(what) {}
};
}
namespace enum_hpp::detail namespace enum_hpp::detail
{ {
@@ -94,7 +86,7 @@ namespace enum_hpp::detail
enum Enum : Type {\ enum Enum : Type {\
ENUM_HPP_GENERATE_ENUM_FIELDS(Fields)\ ENUM_HPP_GENERATE_ENUM_FIELDS(Fields)\
};\ };\
ENUM_HPP_TRAITS_IMPL(Enum, Type, Fields) ENUM_HPP_TRAITS_DECL(Enum, Fields)
// //
// ENUM_HPP_CLASS_DECL // ENUM_HPP_CLASS_DECL
@@ -104,47 +96,58 @@ namespace enum_hpp::detail
enum class Enum : Type {\ enum class Enum : Type {\
ENUM_HPP_GENERATE_ENUM_FIELDS(Fields)\ ENUM_HPP_GENERATE_ENUM_FIELDS(Fields)\
};\ };\
ENUM_HPP_TRAITS_IMPL(Enum, Type, Fields) ENUM_HPP_TRAITS_DECL(Enum, Fields)
// //
// ENUM_HPP_TRAITS_IMPL // ENUM_HPP_TRAITS_DECL
// //
#define ENUM_HPP_TRAITS_IMPL(Enum, Type, Fields)\ #define ENUM_HPP_TRAITS_DECL(Enum, Fields)\
struct Enum##_traits {\ struct Enum##_traits {\
private:\ private:\
enum enum_names_for_this_score_ { ENUM_HPP_GENERATE_ENUM_FIELDS(Fields) };\ enum enum_names_for_this_score_ { ENUM_HPP_GENERATE_ENUM_FIELDS(Fields) };\
public:\ public:\
using underlying_type = std::underlying_type_t<Enum>;\
static constexpr std::size_t size = ENUM_HPP_PP_SEQ_SIZE(Fields);\ static constexpr std::size_t size = ENUM_HPP_PP_SEQ_SIZE(Fields);\
static constexpr const Enum values[] = { ENUM_HPP_GENERATE_VALUES(Enum, Fields) };\ static constexpr const Enum values[] = { ENUM_HPP_GENERATE_VALUES(Enum, Fields) };\
static constexpr const std::string_view names[] = { ENUM_HPP_GENERATE_NAMES(Fields) };\ static constexpr const std::string_view names[] = { ENUM_HPP_GENERATE_NAMES(Fields) };\
public:\ public:\
static constexpr std::string_view to_string(Enum e) noexcept {\ static constexpr underlying_type to_underlying(Enum e) noexcept {\
return static_cast<underlying_type>(e);\
}\
\
static constexpr std::optional<std::string_view> to_string(Enum e) noexcept {\
for ( std::size_t i = 0; i < size; ++i) {\ for ( std::size_t i = 0; i < size; ++i) {\
if ( e == values[i] ) {\ if ( e == values[i] ) {\
return names[i];\ return names[i];\
}\ }\
}\ }\
return std::string_view();\ return std::nullopt;\
}\ }\
\ \
static Enum from_string(std::string_view name){\ static constexpr std::optional<Enum> from_string(std::string_view name) noexcept {\
for ( std::size_t i = 0; i < size; ++i) {\ for ( std::size_t i = 0; i < size; ++i) {\
if ( name == names[i] ) {\ if ( name == names[i] ) {\
return values[i];\ return values[i];\
}\ }\
}\ }\
throw ::enum_hpp::exception(#Enum "_traits::from_string(): invalid argument");\ return std::nullopt;\
}\ }\
\ \
static constexpr bool from_string_nothrow(std::string_view name, Enum& result) noexcept {\ static constexpr std::optional<std::size_t> to_index(Enum e) noexcept {\
for ( std::size_t i = 0; i < size; ++i) {\ for ( std::size_t i = 0; i < size; ++i ) {\
if ( name == names[i] ) {\ if ( e == values[i] ) {\
result = values[i];\ return i;\
return true;\
}\ }\
}\ }\
return false;\ return std::nullopt;\
}\
\
static constexpr std::optional<Enum> from_index(std::size_t index) noexcept {\
if ( index < size ) {\
return values[index];\
}\
return std::nullopt;\
}\ }\
}; };

53
untests/enum_examples.cpp Normal file
View File

@@ -0,0 +1,53 @@
/*******************************************************************************
* This file is part of the "https://github.com/blackmatov/enum.hpp"
* For conditions of distribution and use, see copyright notice in LICENSE.md
* Copyright (C) 2019, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#define CATCH_CONFIG_FAST_COMPILE
#include <catch2/catch.hpp>
#include <enum.hpp/enum.hpp>
#include <string>
#include <iostream>
namespace
{
ENUM_HPP_CLASS_DECL(color, unsigned,
(red = 0xFF0000)
(green = 0x00FF00)
(blue = 0x0000FF)
(white = red | green | blue))
}
TEST_CASE("examples") {
SECTION("traits_using") {
// size
STATIC_REQUIRE(color_traits::size == 4);
// to_underlying
STATIC_REQUIRE(color_traits::to_underlying(color::white) == 0xFFFFFF);
// to_string
STATIC_REQUIRE(color_traits::to_string(color::red) == "red");
STATIC_REQUIRE(color_traits::to_string(color(42)) == std::nullopt);
// from_string
STATIC_REQUIRE(color_traits::from_string("green") == color::green);
STATIC_REQUIRE(color_traits::from_string("error") == std::nullopt);
// to_index
STATIC_REQUIRE(color_traits::to_index(color::blue) == 2u);
STATIC_REQUIRE(color_traits::to_index(color(42)) == std::nullopt);
// from_index
STATIC_REQUIRE(color_traits::from_index(2) == color::blue);
STATIC_REQUIRE(color_traits::from_index(42) == std::nullopt);
// names
for ( auto n : color_traits::names ) {
std::cout << n << ",";
}
}
}

129
untests/enum_tests.cpp
View File

@@ -64,19 +64,19 @@ TEST_CASE("enum") {
std::underlying_type_t<sn::color>, std::underlying_type_t<sn::color>,
unsigned>); unsigned>);
REQUIRE(enum_to_underlying(sn::color::red) == 2); REQUIRE(enum_to_underlying(sn::color::red) == 2u);
REQUIRE(enum_to_underlying(sn::color::green) == 3); REQUIRE(enum_to_underlying(sn::color::green) == 3u);
REQUIRE(enum_to_underlying(sn::color::blue) == 6); REQUIRE(enum_to_underlying(sn::color::blue) == 6u);
} }
{ {
STATIC_REQUIRE(std::is_same_v< STATIC_REQUIRE(std::is_same_v<
std::underlying_type_t<sn::render::mask>, std::underlying_type_t<sn::render::mask>,
unsigned char>); unsigned char>);
REQUIRE(enum_to_underlying(sn::render::mask::none) == 0); REQUIRE(enum_to_underlying(sn::render::mask::none) == 0u);
REQUIRE(enum_to_underlying(sn::render::mask::color) == 1); REQUIRE(enum_to_underlying(sn::render::mask::color) == 1u);
REQUIRE(enum_to_underlying(sn::render::mask::alpha) == 2); REQUIRE(enum_to_underlying(sn::render::mask::alpha) == 2u);
REQUIRE(enum_to_underlying(sn::render::mask::all) == 3); REQUIRE(enum_to_underlying(sn::render::mask::all) == 3u);
} }
{ {
STATIC_REQUIRE(std::is_same_v< STATIC_REQUIRE(std::is_same_v<
@@ -91,28 +91,49 @@ TEST_CASE("enum") {
SECTION("size") { SECTION("size") {
{ {
REQUIRE(sn::color_traits::size == 3); REQUIRE(sn::color_traits::size == 3u);
REQUIRE(sn::color_traits::size == std::size(sn::color_traits::names)); REQUIRE(sn::color_traits::size == std::size(sn::color_traits::names));
REQUIRE(sn::color_traits::size == std::size(sn::color_traits::values)); REQUIRE(sn::color_traits::size == std::size(sn::color_traits::values));
} }
{ {
REQUIRE(sn::render::mask_traits::size == 4); REQUIRE(sn::render::mask_traits::size == 4u);
REQUIRE(sn::render::mask_traits::size == std::size(sn::render::mask_traits::names)); REQUIRE(sn::render::mask_traits::size == std::size(sn::render::mask_traits::names));
REQUIRE(sn::render::mask_traits::size == std::size(sn::render::mask_traits::values)); REQUIRE(sn::render::mask_traits::size == std::size(sn::render::mask_traits::values));
} }
{ {
REQUIRE(sn::numbers_traits::size == 241); REQUIRE(sn::numbers_traits::size == 241u);
REQUIRE(sn::numbers_traits::size == std::size(sn::numbers_traits::names)); REQUIRE(sn::numbers_traits::size == std::size(sn::numbers_traits::names));
REQUIRE(sn::numbers_traits::size == std::size(sn::numbers_traits::values)); REQUIRE(sn::numbers_traits::size == std::size(sn::numbers_traits::values));
} }
} }
SECTION("to_underlying") {
{
STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color::red) == enum_to_underlying(sn::color::red));
STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color::green) == enum_to_underlying(sn::color::green));
STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color::blue) == enum_to_underlying(sn::color::blue));
STATIC_REQUIRE(sn::color_traits::to_underlying(sn::color(42)) == 42);
}
{
STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::none) == enum_to_underlying(sn::render::mask::none));
STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::color) == enum_to_underlying(sn::render::mask::color));
STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::alpha) == enum_to_underlying(sn::render::mask::alpha));
STATIC_REQUIRE(sn::render::mask_traits::to_underlying(sn::render::mask::all) == enum_to_underlying(sn::render::mask::all));
}
{
STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::_0) == enum_to_underlying(sn::_0));
STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::_180) == enum_to_underlying(sn::_180));
STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::_240) == enum_to_underlying(sn::_240));
STATIC_REQUIRE(sn::numbers_traits::to_underlying(sn::numbers(100500)) == 100500);
}
}
SECTION("to_string") { SECTION("to_string") {
{ {
STATIC_REQUIRE(sn::color_traits::to_string(sn::color::red) == "red"); STATIC_REQUIRE(sn::color_traits::to_string(sn::color::red) == "red");
STATIC_REQUIRE(sn::color_traits::to_string(sn::color::green) == "green"); STATIC_REQUIRE(sn::color_traits::to_string(sn::color::green) == "green");
STATIC_REQUIRE(sn::color_traits::to_string(sn::color::blue) == "blue"); STATIC_REQUIRE(sn::color_traits::to_string(sn::color::blue) == "blue");
STATIC_REQUIRE(sn::color_traits::to_string(sn::color(42)) == ""); STATIC_REQUIRE_FALSE(sn::color_traits::to_string(sn::color(42)));
} }
{ {
STATIC_REQUIRE(sn::render::mask_traits::to_string(sn::render::mask::none) == "none"); STATIC_REQUIRE(sn::render::mask_traits::to_string(sn::render::mask::none) == "none");
@@ -124,62 +145,70 @@ TEST_CASE("enum") {
STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_0) == "_0"); STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_0) == "_0");
STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_180) == "_180"); STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_180) == "_180");
STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_240) == "_240"); STATIC_REQUIRE(sn::numbers_traits::to_string(sn::_240) == "_240");
STATIC_REQUIRE(sn::numbers_traits::to_string(sn::numbers(100500)) == ""); STATIC_REQUIRE_FALSE(sn::numbers_traits::to_string(sn::numbers(100500)));
} }
} }
SECTION("from_string") { SECTION("from_string") {
{ {
REQUIRE(sn::color_traits::from_string("red") == sn::color::red); STATIC_REQUIRE(sn::color_traits::from_string("red") == sn::color::red);
REQUIRE(sn::color_traits::from_string("green") == sn::color::green); STATIC_REQUIRE(sn::color_traits::from_string("green") == sn::color::green);
REQUIRE(sn::color_traits::from_string("blue") == sn::color::blue); STATIC_REQUIRE(sn::color_traits::from_string("blue") == sn::color::blue);
REQUIRE_THROWS_AS(sn::color_traits::from_string("42"), enum_hpp::exception); STATIC_REQUIRE_FALSE(sn::color_traits::from_string("42"));
} }
{ {
REQUIRE(sn::render::mask_traits::from_string("none") == sn::render::mask::none); STATIC_REQUIRE(sn::render::mask_traits::from_string("none") == sn::render::mask::none);
REQUIRE(sn::render::mask_traits::from_string("color") == sn::render::mask::color); STATIC_REQUIRE(sn::render::mask_traits::from_string("color") == sn::render::mask::color);
REQUIRE(sn::render::mask_traits::from_string("alpha") == sn::render::mask::alpha); STATIC_REQUIRE(sn::render::mask_traits::from_string("alpha") == sn::render::mask::alpha);
REQUIRE(sn::render::mask_traits::from_string("all") == sn::render::mask::all); STATIC_REQUIRE(sn::render::mask_traits::from_string("all") == sn::render::mask::all);
REQUIRE_THROWS_AS(sn::render::mask_traits::from_string("42"), enum_hpp::exception); STATIC_REQUIRE_FALSE(sn::render::mask_traits::from_string("42"));
} }
{ {
REQUIRE(sn::numbers_traits::from_string("_10") == sn::_10); STATIC_REQUIRE(sn::numbers_traits::from_string("_10") == sn::_10);
REQUIRE(sn::numbers_traits::from_string("_240") == sn::_240); STATIC_REQUIRE(sn::numbers_traits::from_string("_240") == sn::_240);
REQUIRE_THROWS_AS(sn::numbers_traits::from_string("error"), enum_hpp::exception); STATIC_REQUIRE_FALSE(sn::numbers_traits::from_string("error"));
} }
} }
SECTION("from_string_nothrow") { SECTION("to_index") {
{ {
sn::color result{42}; STATIC_REQUIRE(sn::color_traits::to_index(sn::color::red) == 0u);
REQUIRE(sn::color_traits::from_string_nothrow("red", result)); STATIC_REQUIRE(sn::color_traits::to_index(sn::color::green) == 1u);
REQUIRE(result == sn::color::red); STATIC_REQUIRE(sn::color_traits::to_index(sn::color::blue) == 2u);
REQUIRE(sn::color_traits::from_string_nothrow("green", result)); STATIC_REQUIRE_FALSE(sn::color_traits::to_index(sn::color(42)));
REQUIRE(result == sn::color::green);
REQUIRE(sn::color_traits::from_string_nothrow("blue", result));
REQUIRE(result == sn::color::blue);
REQUIRE_FALSE(sn::color_traits::from_string_nothrow("42", result));
REQUIRE(result == sn::color::blue);
} }
{ {
sn::render::mask result{42}; STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::none) == 0u);
REQUIRE(sn::render::mask_traits::from_string_nothrow("none", result)); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::color) == 1u);
REQUIRE(result == sn::render::mask::none); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::alpha) == 2u);
REQUIRE(sn::render::mask_traits::from_string_nothrow("color", result)); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::all) == 3u);
REQUIRE(result == sn::render::mask::color);
REQUIRE(sn::render::mask_traits::from_string_nothrow("alpha", result));
REQUIRE(result == sn::render::mask::alpha);
REQUIRE(sn::render::mask_traits::from_string_nothrow("all", result));
REQUIRE(result == sn::render::mask::all);
REQUIRE_FALSE(sn::render::mask_traits::from_string_nothrow("42", result));
REQUIRE(result == sn::render::mask::all);
} }
{ {
sn::numbers result{100500}; STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_0) == 0u);
REQUIRE(sn::numbers_traits::from_string_nothrow("_240", result)); STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_180) == 180u);
REQUIRE(result == sn::_240); STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_240) == 240u);
REQUIRE_FALSE(sn::numbers_traits::from_string_nothrow("error", result)); STATIC_REQUIRE_FALSE(sn::numbers_traits::to_index(sn::numbers(100500)));
REQUIRE(result == sn::_240); }
}
SECTION("from_index") {
{
STATIC_REQUIRE(sn::color_traits::from_index(0) == sn::color::red);
STATIC_REQUIRE(sn::color_traits::from_index(1) == sn::color::green);
STATIC_REQUIRE(sn::color_traits::from_index(2) == sn::color::blue);
STATIC_REQUIRE_FALSE(sn::color_traits::from_index(42));
}
{
STATIC_REQUIRE(sn::render::mask_traits::from_index(0) == sn::render::mask::none);
STATIC_REQUIRE(sn::render::mask_traits::from_index(1) == sn::render::mask::color);
STATIC_REQUIRE(sn::render::mask_traits::from_index(2) == sn::render::mask::alpha);
STATIC_REQUIRE(sn::render::mask_traits::from_index(3) == sn::render::mask::all);
STATIC_REQUIRE_FALSE(sn::render::mask_traits::from_index(42));
}
{
STATIC_REQUIRE(sn::numbers_traits::from_index(10) == sn::_10);
STATIC_REQUIRE(sn::numbers_traits::from_index(240) == sn::_240);
STATIC_REQUIRE_FALSE(sn::numbers_traits::from_index(100500));
} }
} }
} }