based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit0e84dc494cc423caf5f8c5ee0145bcf75ae97e29
parentf8a9080b0c3d26c6ae26868d7536d38534540a88
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateSun, 16 Mar 2025 22:43:52 +0100

Half-smart enums

Diffstat:
M.clang-tidy|++-
Mexample/empty_example.cpp|+-
Ainclude/based/enum.hpp|+++++++++++++++++++++++++++++++++++++++++++
Minclude/based/instrumentation.hpp|+++++++++++++++++++++++++++++++++++++++++-------------------------------------
Msource/instrumentation.cpp|++---

5 files changed, 89 insertions(+), 42 deletions(-)

diff --git a/.clang-tidy b/.clang-tidy

@@ -11,10 +11,11 @@ Checks: "*,\

-llvm-include-order,\
-llvmlibc-*,\
-cppcoreguidelines-pro-bounds-constant-array-index,\
-modernize-use-nodiscard,\
-misc-include-cleaner,\
-misc-non-private-member-variables-in-classes,\
-modernize-use-nodiscard,\
-modernize-use-trailing-return-type,\
-readability-identifier-length,\
-*-magic-numbers,\
-*-use-ranges,\
"

diff --git a/example/empty_example.cpp b/example/empty_example.cpp

@@ -15,7 +15,7 @@ int main()

instrumented::initialize(vec.size());
std::sort(std::begin(vec), std::end(vec));
for (std::size_t i = 0; i < instrumented::size(); i++) {
for (std::size_t i = 0; i < instrumented::op_num; i++) {
std::cout << std::format(
"{:15}: {}\n", instrumented::name(i), instrumented::count(i));
}

diff --git a/include/based/enum.hpp b/include/based/enum.hpp

@@ -0,0 +1,43 @@

#pragma once
#include <array> // NOLINT
#include <cstddef> // NOLINT
namespace based
{
#define BASED_ENUM(Name, Type, ...) \
class Name \
{ \
public: \
enum Name##_ : Type {__VA_ARGS__}; \
\
private: \
static constexpr const std::array arr = {__VA_ARGS__}; \
\
public: \
static constexpr const std::size_t size = arr.size(); \
\
using enum_type = Name##_; \
\
explicit Name(Name::Name##_ val) \
: m_value(val) \
{ \
} \
\
operator enum_type() const \
{ \
return m_value; \
} \
\
Name& operator=(enum_type val) \
{ \
m_value = val; \
return *this; \
} \
\
private: \
enum_type m_value; \
};
} // namespace based

diff --git a/include/based/instrumentation.hpp b/include/based/instrumentation.hpp

@@ -1,38 +1,34 @@

#pragma once
#include <algorithm>
#include <array>
#include <cmath>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include "based/enum.hpp"
namespace based
{
struct instrumented_base
{
static void initialize(std::size_t size);
static auto size() { return number_ops; }
static auto name(std::size_t idx) { return names[idx]; }
static auto count(std::size_t idx) { return counts[idx]; }
protected:
enum operations : std::uint8_t
{
n,
constructor_default,
constructor_value,
constructor_copy,
constructor_move,
assignment_copy,
assignment_move,
destructor,
equality,
comparison,
_count, // NOLINT
};
static constexpr const std::size_t number_ops = _count;
static constexpr std::array<const char*, number_ops> names = {
BASED_ENUM(op,
std::uint8_t,
n,
ctor_default,
ctor_value,
ctor_copy,
ctor_move,
asgn_copy,
asgn_move,
destructor,
equality,
comparison)
static constexpr std::array<const char*, op::size> names = {
"n",
"ctor_default",
"ctor_value",

@@ -45,48 +41,56 @@ protected:

"comparison",
};
static std::array<double, number_ops> counts;
static std::array<double, op::size> counts;
public:
static constexpr auto op_num = op::size;
static void initialize(std::size_t size);
static constexpr auto name(std::size_t idx) { return names[idx]; }
static auto count(std::size_t idx) { return counts[idx]; }
};
template<typename T>
// T is Semiregualr or Regular or TotallyOrdered
requires std::semiregular<T>
struct instrumented : instrumented_base
{
using value_type = T;
value_type value;
explicit instrumented(value_type val)
instrumented(const value_type& val) // NOLINT *-explicit-constructor
: value(std::move(val))
{
++counts[constructor_value];
++counts[op::ctor_value];
}
explicit instrumented(value_type&& val)
instrumented(value_type&& val) // NOLINT *-explicit-constructor
: value(std::move(val))
{
++counts[constructor_value];
++counts[op::ctor_value];
}
// Semiregular:
instrumented() { ++counts[constructor_default]; }
instrumented() { ++counts[op::ctor_default]; }
instrumented(const instrumented& val)
: value(val.value)
{
++counts[constructor_copy];
++counts[op::ctor_copy];
}
instrumented(instrumented&& val) noexcept
: value(std::move(val.value))
{
++counts[constructor_move];
++counts[op::ctor_move];
}
// self assign should be handled by the value_type
instrumented& operator=(const instrumented& val) // NOLINT cert-oop54-cpp
{
++counts[assignment_copy];
++counts[op::asgn_copy];
value = val.value;
return *this;
}

@@ -94,18 +98,18 @@ struct instrumented : instrumented_base

// self assign should be handled by the value_type
instrumented& operator=(instrumented&& val) noexcept // NOLINT cert-oop54-cpp
{
++counts[assignment_move];
++counts[op::asgn_move];
value = std::move(val.value);
return *this;
}
~instrumented() { ++counts[destructor]; }
~instrumented() { ++counts[op::destructor]; }
// Regular
friend bool operator==(const instrumented& lhs, const instrumented& rhs)
{
++counts[equality];
++counts[op::equality];
return lhs.value == rhs.value;
}

@@ -118,7 +122,7 @@ struct instrumented : instrumented_base

friend bool operator<(const instrumented& lhs, const instrumented& rhs)
{
++counts[comparison];
++counts[op::comparison];
return lhs.value < rhs.value;
}

diff --git a/source/instrumentation.cpp b/source/instrumentation.cpp

@@ -6,13 +6,12 @@

namespace based
{
std::array<double, instrumented_base::number_ops> instrumented_base::counts =
{};
std::array<double, instrumented_base::op_num> instrumented_base::counts = {};
void instrumented_base::initialize(std::size_t size)
{
std::fill(std::begin(counts), std::end(counts), 0.0);
counts[n] = static_cast<double>(size);
counts[op::n] = static_cast<double>(size);
}
} // namespace based