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
before_install:
- eval "${MATRIX_EVAL}"
- if [ "$TRAVIS_OS_NAME" == 'osx' ]; then
brew update;
brew upgrade cmake;
fi
- if [ "$TRAVIS_OS_NAME" == 'linux' ]; then
mkdir $HOME/cmake;
export PATH="$HOME/cmake/bin:$PATH";

68
README.md
View File

@@ -23,6 +23,12 @@
[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
[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 {
using underlying_type = int;
static constexpr std::size_t size = 3;
static constexpr const debug_level values[] = {
@@ -71,15 +78,13 @@ struct debug_level_traits {
"level_warning"
};
static constexpr std::string_view to_string(
debug_level e) noexcept;
static constexpr underlying_type to_underlying(debug_level e) noexcept;
static debug_level from_string(
std::string_view name);
static constexpr std::optional<std::string_view> to_string(debug_level e) noexcept;
static constexpr std::optional<debug_level> from_string(std::string_view name) noexcept;
static constexpr bool from_string_nothrow(
std::string_view name,
debug_level& result) noexcept;
static constexpr std::optional<std::size_t> to_index(debug_level e) noexcept;
static constexpr std::optional<debug_level> from_index(std::size_t index) noexcept;
};
```
@@ -100,6 +105,7 @@ enum class color : unsigned {
};
struct color_traits {
using underlying_type = unsigned;
static constexpr std::size_t size = 4;
static constexpr const color values[] = {
@@ -116,44 +122,56 @@ struct color_traits {
"white"
};
static constexpr std::string_view to_string(
color e) noexcept;
static constexpr underlying_type to_underlying(color e) noexcept;
static color from_string(
std::string_view name);
static constexpr std::optional<std::string_view> to_string(color e) noexcept;
static constexpr std::optional<color> from_string(std::string_view name) noexcept;
static constexpr bool from_string_nothrow(
std::string_view name,
color& result) noexcept;
static constexpr std::optional<std::size_t> to_index(color e) noexcept;
static constexpr std::optional<color> from_index(std::size_t index) noexcept;
};
```
### Traits using
```cpp
ENUM_HPP_CLASS_DECL(color, unsigned, red, green, blue)
namespace
{
ENUM_HPP_CLASS_DECL(color, unsigned,
(red = 0xFF0000)
(green = 0x00FF00)
(blue = 0x0000FF)
(white = red | green | blue))
}
SECTION("traits_using") {
// size
color_traits::size; // 3
STATIC_REQUIRE(color_traits::size == 4);
// to_underlying
STATIC_REQUIRE(color_traits::to_underlying(color::white) == 0xFFFFFF);
// to_string
color_traits::to_string(color::red); // returns "red";
color_traits::to_string(color(42)); // returns "";
STATIC_REQUIRE(color_traits::to_string(color::red) == "red");
STATIC_REQUIRE(color_traits::to_string(color(42)) == std::nullopt);
// from_string
color_traits::from_string("green"); // returns color::green;
color_traits::from_string("error"); // throws enum_hpp::exception
STATIC_REQUIRE(color_traits::from_string("green") == color::green);
STATIC_REQUIRE(color_traits::from_string("error") == std::nullopt);
// from_string_nothrow
color result;
bool success = color_traits::from_string_nothrow("blue", result);
// success == true, result == color::blue
// 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

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

@@ -107,13 +107,13 @@ namespace enum_hpp::detail
private:\
enum enum_names_for_this_score_ { ENUM_HPP_GENERATE_ENUM_FIELDS(Fields) };\
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 const Enum values[] = { ENUM_HPP_GENERATE_VALUES(Enum, Fields) };\
static constexpr const std::string_view names[] = { ENUM_HPP_GENERATE_NAMES(Fields) };\
public:\
static constexpr underlying_t to_underlying(Enum e) noexcept {\
return static_cast<underlying_t>(e);\
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 {\

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