BlackMATov/enum.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/enum.hpp.git synced 2025-12-13 06:59:45 +07:00
Code Issues Packages Projects Releases Wiki Activity

fix readme to new api

Browse Source
This commit is contained in:
Matvey Cherevko
2019-11-22 03:59:49 +07:00
parent aaf1099717
commit 35d63b1b37
5 changed files with 130 additions and 63 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

6
headers/enum.hpp/enum.hpp
View File

@@ -107,13 +107,13 @@ namespace enum_hpp::detail
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_t = std::underlying_type_t<Enum>;\ 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 underlying_t to_underlying(Enum e) noexcept {\ static constexpr underlying_type to_underlying(Enum e) noexcept {\
return static_cast<underlying_t>(e);\ return static_cast<underlying_type>(e);\
}\ }\
\ \
static constexpr std::optional<std::string_view> to_string(Enum e) noexcept {\ static constexpr std::optional<std::string_view> to_string(Enum e) noexcept {\

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 << ",";
}
}
}

40
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,17 +91,17 @@ 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));
} }
@@ -172,21 +172,21 @@ TEST_CASE("enum") {
SECTION("to_index") { SECTION("to_index") {
{ {
STATIC_REQUIRE(sn::color_traits::to_index(sn::color::red) == 0); STATIC_REQUIRE(sn::color_traits::to_index(sn::color::red) == 0u);
STATIC_REQUIRE(sn::color_traits::to_index(sn::color::green) == 1); STATIC_REQUIRE(sn::color_traits::to_index(sn::color::green) == 1u);
STATIC_REQUIRE(sn::color_traits::to_index(sn::color::blue) == 2); STATIC_REQUIRE(sn::color_traits::to_index(sn::color::blue) == 2u);
STATIC_REQUIRE_FALSE(sn::color_traits::to_index(sn::color(42))); STATIC_REQUIRE_FALSE(sn::color_traits::to_index(sn::color(42)));
} }
{ {
STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::none) == 0); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::none) == 0u);
STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::color) == 1); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::color) == 1u);
STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::alpha) == 2); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::alpha) == 2u);
STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::all) == 3); STATIC_REQUIRE(sn::render::mask_traits::to_index(sn::render::mask::all) == 3u);
} }
{ {
STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_0) == 0); STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_0) == 0u);
STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_180) == 180); STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_180) == 180u);
STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_240) == 240); STATIC_REQUIRE(sn::numbers_traits::to_index(sn::_240) == 240u);
STATIC_REQUIRE_FALSE(sn::numbers_traits::to_index(sn::numbers(100500))); STATIC_REQUIRE_FALSE(sn::numbers_traits::to_index(sn::numbers(100500)));
} }
} }