types.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <string_view>
#include <cxxabi.h>
#include "attributes/common.hpp"
 
using namespace std;
 
 
namespace ein {
 
template <typename T>
const string_view type = [] ein_nodiscard ein_const static noexcept -> string_view {
  // nb: copying into string is necessary because the demangled name is ephemeral
  static const string body = [] ein_nodiscard ein_const static noexcept -> char const * {
    int status;
    return abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
  }();
  return body;
}();
 
ein_nodiscard ein_const
const string_view type_of(auto const & t) noexcept {
  return type<remove_cvref_t<decltype(t)>>;
}
 
template <typename T, typename ... candidates>
concept one_of_t = (std::is_same_v<T,candidates> || ... || false);
 
template <typename T, typename ... candidates>
concept not_one_of_t = (!one_of_t<T,candidates...>);
}
 
#if defined(EIN_TESTING) || defined(EIN_TESTING_TYPES)
#include <string_view>
#include "types.hpp"
 
struct Custom {};
 
TEST_CASE("types","[types]") {
  using namespace ein;
  SECTION("provides correct demangled names") {
    SECTION("Basic types") {
      CHECK("int"s == type<int>);
      CHECK("double"s == type<double>);
    }
 
    SECTION("User-defined types") {
      CHECK(type<Custom> == "Custom"s);
    }
 
    SECTION("Pointers and References") {
      CHECK(type<int*> == "int*");
      CHECK(type<int&> == "int");
      CHECK(type<int&> == "int");
    }
  }
 
  SECTION("type_of extracts type from object") {
    SECTION("Literals and basic types") {
      int i = 42;
      double d = 3.14;
      CHECK(type_of(i) == "int");
      CHECK(type_of(d) == "double");
    }
 
    SECTION("Constant and reference types") {
      const int ci = 42;
      CHECK(type_of(ci) == "int");
 
      int i = 34;
      int& ri = i;
      REQUIRE(type_of(ri) == "int");
    }
  }
 
  SECTION("one_of_t concept identifies types within list") {
    using namespace ein;
    SECTION("Valid and invalid cases") {
      REQUIRE(one_of_t<int, int, double, float>);
      REQUIRE_FALSE(one_of_t<char, int, double, float>);
    }
  }
 
  SECTION("not_one_of_t concept identifies types outside of list") {
    using namespace ein;
    SECTION("Valid and invalid cases") {
      REQUIRE(not_one_of_t<char, int, double, float>);
      REQUIRE_FALSE(not_one_of_t<int, int, double, float>);
    }
  }
}
#endif