Dependencies cleanup

.clang-format

@@ -6,7 +6,7 @@ ContinuationIndentWidth: 8
 ColumnLimit: 100
 AllowShortFunctionsOnASingleLine: Empty
 IncludeCategories:
-  - Regex: '<(spdlog|boost|enum|gmock|gtest|pybind11|Python|frozen).+>'
+  - Regex: '<(spdlog|boost|magic_enum|gmock|gtest|pybind11|Python).+>'
     Priority: 2
   - Regex: '<.+>'
     Priority: 1

CMakeLists.txt

@@ -256,28 +256,11 @@ CPMAddPackage("gh:ktprime/emhash#5f327039a2776f38910e600889acf924a2d99ea3")
 include_directories(SYSTEM "${emhash_SOURCE_DIR}")
 
 CPMAddPackage(
-    NAME frozen
-    GITHUB_REPOSITORY serge-sans-paille/frozen
-    GIT_TAG 1.2.0
-    DOWNLOAD_ONLY True
-)
-include_directories(SYSTEM "${frozen_SOURCE_DIR}/include")
-
-CPMAddPackage(
-    NAME better-enums
-    GITHUB_REPOSITORY aantron/better-enums
-    GIT_TAG 0.11.3
-    DOWNLOAD_ONLY True
-)
-include_directories(SYSTEM "${better-enums_SOURCE_DIR}")
-
-CPMAddPackage(
-    NAME atomicbitvector
-    GITHUB_REPOSITORY ekg/atomicbitvector
-    GIT_TAG e295358fea9532fa4c37197630d037a4a53ddede
-    DOWNLOAD_ONLY True
+    NAME magic_enum
+    GITHUB_REPOSITORY Neargye/magic_enum
+    VERSION 0.9.7
+    SYSTEM YES
 )
-include_directories(SYSTEM "${atomicbitvector_SOURCE_DIR}/include")
 
 if(DESBORDANTE_BUILD_TESTS)
     CPMAddPackage(

src/core/CMakeLists.txt

@@ -37,6 +37,7 @@ target_link_libraries(
     PRIVATE ${Boost_LIBRARIES} # Boost components specified in find_package
             Threads::Threads # System threading library
     PUBLIC spdlog::spdlog_header_only # Logging infrastructure exposed in headers
+           magic_enum::magic_enum # Enum reflection used in headers
 )
 
 # Propagate the setting to all consumers of the library

src/core/algorithms/algebraic_constraints/ac_algorithm.cpp

@@ -26,16 +26,16 @@ void ACAlgorithm::RegisterOptions() {
 
     auto check_and_set_binop = [this](Binop bin_operation) {
         switch (bin_operation) {
-            case +Binop::Addition:
+            case Binop::kAddition:
                 binop_pointer_ = &model::INumericType::Add;
                 break;
-            case +Binop::Subtraction:
+            case Binop::kSubtraction:
                 binop_pointer_ = &model::INumericType::Sub;
                 break;
-            case +Binop::Multiplication:
+            case Binop::kMultiplication:
                 binop_pointer_ = &model::INumericType::Mul;
                 break;
-            case +Binop::Division:
+            case Binop::kDivision:
                 binop_pointer_ = &model::INumericType::Div;
                 break;
             default:
@@ -172,7 +172,7 @@ std::vector<std::byte const*> ACAlgorithm::SamplingIteration(
             }
             auto res = std::unique_ptr<std::byte[]>(num_type_->Allocate());
             num_type_->ValueFromStr(res.get(), "0");
-            if (bin_operation_ == +Binop::Division &&
+            if (bin_operation_ == Binop::kDivision &&
                 num_type_->Compare(r, res.get()) == model::CompareResult::kEqual) {
                 continue;
             }
@@ -335,7 +335,7 @@ unsigned long long ACAlgorithm::ExecuteInternal() {
                 /* Because of asymmetry and division by 0, we need to rediscover ranges.
                  * We don't need to do that for minus: (column1 - column2) lies in *some ranges*
                  * there we can express one column through another without possible problems */
-                if (bin_operation_ == +Binop::Division) {
+                if (bin_operation_ == Binop::kDivision) {
                     ranges_.emplace_back(
                             RangesCollection{model::CreateSpecificType<model::INumericType>(
                                                      data.at(col_i).GetTypeId(), true),

src/core/algorithms/algebraic_constraints/ac_algorithm.h

@@ -4,8 +4,6 @@
 #include <unordered_map>
 #include <vector>
 
-#include <enum.h>
-
 #include "core/algorithms/algebraic_constraints/ac.h"
 #include "core/algorithms/algebraic_constraints/ac_exception.h"
 #include "core/algorithms/algebraic_constraints/ac_exception_finder.h"
@@ -39,7 +37,7 @@ class ACAlgorithm : public Algorithm {
 
     config::InputTable input_table_;
 
-    Binop bin_operation_ = Binop::_values()[0];
+    Binop bin_operation_ = magic_enum::enum_values<Binop>().front();
     /* Desired ratio of exceptions. Value lies in (0, 1] */
     double fuzziness_;
     /* Value lies in (0, 1]. Closer to 0 - many short intervals.

src/core/algorithms/algebraic_constraints/ac_exception_finder.cpp

@@ -49,7 +49,7 @@ void ACExceptionFinder::CollectColumnPairExceptions(std::vector<model::TypedColu
         }
         auto res = std::unique_ptr<std::byte[]>(num_type->Allocate());
         num_type->ValueFromStr(res.get(), "0");
-        if (ac_alg_->GetBinOperation() == +Binop::Division &&
+        if (ac_alg_->GetBinOperation() == Binop::kDivision &&
             num_type->Compare(r, res.get()) == model::CompareResult::kEqual) {
             continue;
         }

src/core/algorithms/algebraic_constraints/bin_operation_enum.h

@@ -1,9 +1,13 @@
 #pragma once
 
-#include <enum.h>
+#include <magic_enum/magic_enum.hpp>
 
 namespace algos {
 
-BETTER_ENUM(Binop, char, Addition = '+', Subtraction = '-', Multiplication = '*', Division = '/');
-
+enum class Binop : char {
+    kAddition = '+',
+    kSubtraction = '-',
+    kMultiplication = '*',
+    kDivision = '/'
+};
 }  // namespace algos

src/core/algorithms/algorithm_types.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <enum.h>
+#include <magic_enum/magic_enum.hpp>
 
 #include "core/algorithms/algorithms.h"
 
@@ -21,87 +21,88 @@ using AlgorithmTypes =
  * NOTE: algorithm string name representation is taken from the value in this
  * enum, so name it appropriately (lowercase and without additional symbols).
  */
-BETTER_ENUM(AlgorithmType, char,
+
+enum class AlgorithmType : char {
 /* Functional dependency mining algorithms */
-    depminer = 0,
-    dfd,
-    fastfds,
-    fdep,
-    fdmine,
-    pyro,
-    tane,
-    pfdtane,
-    fun,
-    hyfd,
-    aidfd,
-    eulerfd,
+    kDepminer = 0,
+    kDfd,
+    kFastfds,
+    kFdep,
+    kFdmine,
+    kPyro,
+    kTane,
+    kPfdtane,
+    kFun,
+    kHyfd,
+    kAidfd,
+    kEulerfd,
 
 /* Association rules mining algorithms */
-    apriori,
+    kApriori,
 
 /* Numerical association rules mining algorithms*/
-    des,
+    kDes,
 
 /* Metric verifier algorithm */
-    metric,
+    kMetric,
 
 /* Statistic algorithms */
-    stats,
+    kStats,
 
 /* FD verifier algorithm */
-    fd_verifier,
+    kFdVerifier,
 
 /* Unique Column Combination mining algorithms */
-    hyucc,
-    pyroucc,
-    hpivalid,
+    kHyucc,
+    kPyroucc,
+    kHpivalid,
 
 /* CFD mining algorithms */
-    fd_first_dfs,
+    kFdFirstDfs,
 
 /* Algebraic constraints mining algorithm*/
-    ac,
+    kAc,
 
 /* UCC verifier algorithm */
-    ucc_verifier,
+    kUccVerifier,
 
 /* Inclusion dependency mining algorithms */
-    faida,
-    spider,
-    mind,
+    kFaida,
+    kSpider,
+    kMind,
 
 /* IND verifier algorithm */
-    ind_verifier,
+    kIndVerifier,
 
 /* Order dependency mining algorithms */
-    fastod,
+    kFastod,
 
 /* Graph functional dependency mining algorithms */
-    gfdvalid,
-    egfdvalid,
-    naivegfdvalid,
+    kGfdvalid,
+    kEgfdvalid,
+    kNaivegfdvalid,
 
 /* Order dependency mining algorithms */
-    order,
+    kOrder,
 
 /* Differential dependencies mining algorithm */
-    split,
+    kSplit,
 
 /* SFD mining algorithm */
-    cords,
+    kCords,
 
 /* MD mining algorithms */
-    hymd,
+    kHymd,
 
 /* PFD verifier algorithm */
-    pfd_verifier,
+    kPfdVerifier,
 
 /* CFD verifier algorithm */
-    cfd_verifier
-)
+    kCfdVerifier
+};
 // clang-format on
 
-static_assert(std::tuple_size_v<AlgorithmTypes> == AlgorithmType::_size(),
+static_assert(std::tuple_size_v<AlgorithmTypes> == magic_enum::enum_count<AlgorithmType>(),
               "The AlgorithmTypes tuple and the AlgorithmType enum sizes must be the same. Did you "
               "forget to add your new algorithm to either of those?");
 

src/core/algorithms/association_rules/ar_algorithm.cpp

@@ -20,8 +20,8 @@ ARAlgorithm::ARAlgorithm(std::vector<std::string_view> phase_names)
 void ARAlgorithm::RegisterOptions() {
     DESBORDANTE_OPTION_USING;
 
-    auto sing_eq = [](InputFormat input_format) { return input_format == +InputFormat::singular; };
-    auto tab_eq = [](InputFormat input_format) { return input_format == +InputFormat::tabular; };
+    auto sing_eq = [](InputFormat input_format) { return input_format == InputFormat::kSingular; };
+    auto tab_eq = [](InputFormat input_format) { return input_format == InputFormat::kTabular; };
 
     RegisterOption(config::kTableOpt(&input_table_));
     RegisterOption(Option{&first_column_tid_, kFirstColumnTId, kDFirstColumnTId, false});
@@ -45,11 +45,11 @@ void ARAlgorithm::MakeExecuteOptsAvailable() {
 
 void ARAlgorithm::LoadDataInternal() {
     switch (input_format_) {
-        case InputFormat::singular:
+        case InputFormat::kSingular:
             transactional_data_ = model::TransactionalData::CreateFromSingular(
                     *input_table_, tid_column_index_, item_column_index_);
             break;
-        case InputFormat::tabular:
+        case InputFormat::kTabular:
             transactional_data_ =
                     model::TransactionalData::CreateFromTabular(*input_table_, first_column_tid_);
             break;

src/core/algorithms/association_rules/ar_algorithm.h

@@ -20,7 +20,7 @@ class ARAlgorithm : public Algorithm {
     config::InputTable input_table_;
 
     double minconf_;
-    InputFormat input_format_ = InputFormat::singular;
+    InputFormat input_format_ = InputFormat::kSingular;
     unsigned int tid_column_index_;
     unsigned int item_column_index_;
     bool first_column_tid_;

src/core/algorithms/association_rules/ar_algorithm_enums.h

@@ -1,9 +1,8 @@
 #pragma once
 
-#include <enum.h>
+#include <magic_enum/magic_enum.hpp>
 
 namespace algos {
 
-BETTER_ENUM(InputFormat, char, singular = 0, tabular);
-
+enum class InputFormat : char { kSingular = 0, kTabular };
 }  // namespace algos

src/core/algorithms/cfd/enums.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#include <enum.h>
+#include <magic_enum/magic_enum.hpp>
 
 namespace algos::cfd {
 
-// Defines what kind of lattice traversal will be used in pattern mining part of the algorithm.
-BETTER_ENUM(Substrategy, char,
-            dfs = 0,  // dfs lattice traversal
-            bfs       // bfs lattice traversal
-);
+enum class Substrategy : char {
+    kDfs = 0,  // dfs lattice traversal
+    kBfs       // bfs lattice traversal
+};
 }  // namespace algos::cfd

src/core/algorithms/cfd/fd_first_algorithm.cpp

@@ -25,7 +25,7 @@ FDFirstAlgorithm::FDFirstAlgorithm() : CFDDiscovery({kDefaultPhaseName}) {
 void FDFirstAlgorithm::RegisterOptions() {
     DESBORDANTE_OPTION_USING;
 
-    Substrategy default_val = Substrategy::dfs;
+    Substrategy default_val = Substrategy::kDfs;
     RegisterOption(Option{&min_supp_, kCfdMinimumSupport, kDCfdMinimumSupport, 0u});
     RegisterOption(Option{&min_conf_, kCfdMinimumConfidence, kDCfdMinimumConfidence, 0.0});
     RegisterOption(Option{&max_lhs_, kCfdMaximumLhs, kDCfdMaximumLhs, 0u});
@@ -230,9 +230,9 @@ void FDFirstAlgorithm::FdsFirstDFS(Itemset const& prefix, PIdListMiners const& i
             Itemset const sub = ConstructSubset(iset, out);
             MineFD(inode, sub, out);
 
-            if (ss == +Substrategy::dfs) {
+            if (ss == Substrategy::kDfs) {
                 MinePatternsDFS(sub, out, inode.tids);
-            } else if (ss == +Substrategy::bfs) {
+            } else if (ss == Substrategy::kBfs) {
                 MinePatternsBFS(sub, out, inode.tids);
             }
         }

src/core/algorithms/cfd/fd_first_algorithm.h

@@ -19,7 +19,7 @@ class FDFirstAlgorithm : public algos::cfd::CFDDiscovery {
     unsigned max_cfd_size_;
     unsigned max_lhs_;
     double min_conf_;
-    Substrategy substrategy_ = Substrategy::dfs;
+    Substrategy substrategy_ = Substrategy::kDfs;
 
     std::map<Itemset, PartitionTIdList> store_;
     PrefixTree<Itemset, Itemset> cand_store_;
@@ -33,7 +33,7 @@ class FDFirstAlgorithm : public algos::cfd::CFDDiscovery {
 
     void FdsFirstDFS();
     void FdsFirstDFS(Itemset const &, std::vector<MinerNode<PartitionTIdList>> const &,
-                     Substrategy = Substrategy::dfs);
+                     Substrategy = Substrategy::kDfs);
     void MinePatternsBFS(Itemset const &lhs, int rhs, PartitionTIdList const &all_tids);
     void MinePatternsDFS(Itemset const &lhs, int rhs, PartitionTIdList const &all_tids);
     void MinePatternsDFS(Itemset const &, std::vector<MinerNode<SimpleTIdList>> &, Itemset const &,

src/core/algorithms/create_algorithm.h

@@ -37,7 +37,7 @@ bool IsBaseOf(AlgorithmType algorithm) {
 template <typename AlgorithmBase>
 std::vector<AlgorithmType> GetAllDerived() {
     std::vector<AlgorithmType> derived_from_base{};
-    for (AlgorithmType algo : AlgorithmType::_values()) {
+    for (AlgorithmType algo : magic_enum::enum_values<AlgorithmType>()) {
         if (IsBaseOf<AlgorithmBase>(algo)) {
             derived_from_base.push_back(algo);
         }

src/core/algorithms/dc/FastADC/fastadc.cpp

@@ -74,13 +74,13 @@ void FastADC::CheckTypes() {
         model::TypedColumnData const& column = typed_relation_->GetColumnData(column_index);
         model::TypeId type_id = column.GetTypeId();
 
-        if (type_id == +model::TypeId::kMixed) {
+        if (type_id == model::TypeId::kMixed) {
             LOG_WARN(
                     "Column with index \"{}\" contains values of different types. Those values "
                     "will be "
                     "treated as strings.",
                     column_index);
-        } else if (!column.IsNumeric() && type_id != +model::TypeId::kString) {
+        } else if (!column.IsNumeric() && type_id != model::TypeId::kString) {
             throw std::invalid_argument(
                     "Column with index \"" + std::to_string(column_index) +
                     "\" is of unsupported type. Only numeric and string types are supported.");