Feature/tags as template args

[mgovers]

replace bool template args with a named tag for comprehensibility

This is something that I've been looking into for a long time now. Dev work on #486 kept getting slower and slower because I was struggling to forward the true and false types. I ended up getting frustrating myself so much that I decided to go ahead with this change.

Example for illustration

template <bool sym>
struct A{
  RealValue<sym> a;
};

using SymA = A<true>;
using AsymA = A<false>;

becomes

template <symmetry_tag sym>
struct A{
  RealValue<sym> a;
};

using SymA = A<symmetric_t>;
using AsymA = A<asymmetric_t>;

This makes types like RealValue<symmetric_t> and functions get_output<asymmetric_t> much more comprehensible than existing RealValue<false> and get_output<false>, resp.

Example on datasets to really show why we need this

• DataPointer uses is_const
• but DataHandler uses data_mutable

this is confusing, because in one case true means const and in the other true means mutable

// dataset.hpp
template <bool is_const> class DataPointer {
  // ...
};

// dataset_handler.hpp
template <bool data_mutable, bool indptr_mutable>
    requires(data_mutable || !indptr_mutable)
class DataHandler {
  // ...
};

Introduced constructs

• For every changed construct, 2 tag types are created, one representing the old true value, and one representing the old false value
• A tag concept is created that matches on only those two tag types and nothing else. This is equivalent to the bool part of the template parameter declaration
• A constexpr bool is created to access the true resp false value of the tag types

// tag types
struct symmetric_t{};
struct asymmetric_t{};

// tag concept
template <typename T> symmetry_tag = std::same_as<symmetric_t> || std::same_as<asymmetric_t>;

// tag value
template <symmetry_tag sym> constexpr bool is_symmetric = std::same_as<T, symmetric_t>;

// static asserts
static_assert(symmetry_tag<symmetric_t>);    // it is indeed a tag
static_assert(symmetry_tag<asymmetric_t>);   // it is indeed a tag

static_assert(is_symmetric<symmetric_t>);    // represents current 'true'
static_assert(!is_symmetric<asymmetric_t>);  // represents current 'false'

Changed constructs

• bool sym for calculation symmetry and object symmetry
• bool is_const for the data set
• bool data_mutable for the data set handler
• bool indptr_mutable for the data set handler
• bool is_gen for load/gen

[TonyXiang8787]

Please read the suggestions.

[sonarcloud]

Quality Gate passed

Issues
88 New issues
0 Accepted issues

Measures
0 Security Hotspots
97.9% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarCloud

[Jerry-Jinfeng-Guo]

Tons of repeated changes, I can see why you were frustrated ;) One minor suggestion: why do we not already declare
using SymComplexValue = ComplexValue<symmetric_t>; using AsymComplexValue = ComplexValue<asymmetric_t>;
throughout the code? This is just one instance.

all comments resolved, no new comments + nitish approved

[mgovers]

Tons of repeated changes, I can see why you were frustrated ;) One minor suggestion: why do we not already declare using SymComplexValue = ComplexValue<symmetric_t>; using AsymComplexValue = ComplexValue<asymmetric_t>; throughout the code? This is just one instance.

out of scope of this ticket. TBD in next refinement