An optional as a customizable trait.
#include <catch2/catch_test_macros.hpp>
#include <variant>
namespace _2p_lib {
TRAIT(equal_comparable, anyxx::dynamic_copyable,
(OP_FREE(bool, ==, eq, (anyxx::self const&), const),
OP_IMPL(
public, bool, !=, ne, (anyxx::self const&), const, (auto const& r) {
return !(as<equal_comparable>(self) ==
as<equal_comparable>(r));
})))
template <typename T>
struct nullable_default_rep : std::variant<std::monostate, T> {
using std::variant<std::monostate, T>::variant;
friend bool operator==(nullable_default_rep const& self,
nullable_default_rep const& r) = default;
};
TRAIT(
nullable, anyxx::dynamic_copyable,
(FN_IMPL(
public, bool, has_value, (), const,
() -> bool { return std::holds_alternative<T>(self); }),
FN_IMPL_EXACT(
public, T const&, get_value, (), const,
()->T const& { return std::get<T>(self); }),
FN_IMPL_EXACT(
public, T&, get_value, (), , ()->T& { return std::get<T>(self); }),
ANY_OP_DEF_EXACT(
public, T const&, ->, arrow_const, (), const,
()->T const& { return Map{}.get_value(self); }),
ANY_OP_DEF_EXACT(
public, T&, ->, arrow, (), , ()->T& { return Map{}.get_value(self); }),
ANY_OP_DEF_EXACT(
public, T const&, *, deref_const, (), const,
()->T const& { return Map{}.get_value(self); }),
ANY_OP_DEF_EXACT(
public, T&, *, deref, (), , ()->T& { return Map{}.get_value(self); }),
OP_FREE(bool, ==, eq, (anyxx::self const&), const)))
template <typename T>
using optional = anyxx::any_<anyxx::using_<T>, nullable>;
template <typename T>
struct reference_wrapper {
T* ptr = nullptr;
reference_wrapper() = default;
reference_wrapper(T& ref) : ptr(&ref) {}
auto get() const { return ptr; }
friend bool operator==(reference_wrapper const& lhs,
reference_wrapper const& rhs) {
return (lhs.ptr == rhs.ptr) || (lhs.ptr && rhs.ptr && *lhs.ptr == *rhs.ptr);
}
};
template <typename T>
struct nullable_trait_map<T&> : nullable_default_trait_map<T const&> {
using rep_type = reference_wrapper<T>;
bool has_value(rep_type const& x) { return x.get() != nullptr; };
auto& get_value(auto&& x) { return *(std::forward<decltype(x)>(x)).get(); };
};
}
TEST_CASE("_2p test optional 1") {
using namespace anyxx;
using namespace _2p_lib;
optional<int> i1{42};
CHECK(i1.has_value());
CHECK(i1.get_value() == 42);
CHECK(*i1 == 42);
CHECK((i1 == optional<int>{42}));
CHECK((i1 != optional<int>{43}));
CHECK((i1 != optional<int>{}));
optional<int> i2;
CHECK(!i2.has_value());
CHECK((i2 == optional<int>{}));
}
namespace _2p_app {
class foo {
public:
class voo {
public:
int i = 0;
};
decltype(auto) operator->(this auto&& self) { return self.v_.get(); }
explicit foo(int i) : v_(std::make_shared<voo>(i)) {}
friend bool operator==(foo const& self, foo const& r) = default;
private:
foo() = default;
std::shared_ptr<voo> v_;
friend struct anyxx::using_<foo>;
friend struct _2p_lib::nullable_trait_map<foo>;
};
}
TRAIT_MAP(_2p_lib::nullable, _2p_app::foo) {
using rep_type = _2p_app::foo;
bool has_value(_2p_app::foo const& self) { return self.v_ != nullptr; };
auto& get_value(auto&& self) { return std::forward<decltype(self)>(self); };
};
namespace {
template <typename T>
bool fun(anyxx::any_<anyxx::using_<T>, _2p_lib::equal_comparable> const& l,
anyxx::any_<anyxx::using_<T>, _2p_lib::equal_comparable> const& r) {
return r == l;
}
static_assert(
_2p_lib::is_equal_comparable_model<
anyxx::any_<anyxx::using_<_2p_app::foo>, _2p_lib::equal_comparable>>);
}
TEST_CASE("_2p test optional 2") {
using namespace anyxx;
using namespace _2p_lib;
using namespace _2p_app;
optional<foo> a1{foo{42}};
static_assert(std::same_as<optional<foo>::rep_type, foo>);
static_assert(std::same_as<using_<foo>, optional<foo>::proxy_t>);
static_assert(sizeof(a1) <= 16);
static_assert(sizeof(foo) == 16);
static_assert(sizeof(a1) == sizeof(foo));
CHECK(a1.has_value());
CHECK(a1.get_value()->i == 42);
CHECK(a1->i == 42);
CHECK((*a1)->i == 42);
auto a1x = a1;
CHECK(a1 == a1x);
CHECK(fun<optional<foo>>(a1, a1x));
CHECK(a1 != optional<foo>{42});
CHECK(a1 != optional<foo>{43});
CHECK(a1 != optional<foo>{});
optional<foo> a2;
CHECK(!a2.has_value());
CHECK(a2 == optional<foo>{});
}
TEST_CASE("_2p test optional 3") {
using namespace anyxx;
using namespace _2p_lib;
int v = 42;
optional<int const&> a1{v};
static_assert(sizeof(a1) == sizeof(int*));
CHECK(a1.has_value());
CHECK(a1.get_value() == 42);
static_assert(
std::is_const_v<std::remove_reference_t<decltype(a1.get_value())>>);
CHECK(*a1 == 42);
auto a1x = a1;
CHECK(a1 == a1x);
CHECK(fun<optional<int const&>>(a1, a1x));
int v1 = 42;
CHECK(a1 == optional<int const&>{v1});
int v2 = 43;
CHECK(a1 != optional<int const&>{v2});
CHECK(a1 != optional<int const&>{});
optional<int const&> a2;
CHECK(!a2.has_value());
CHECK(a2 == optional<int const&>{});
}
TEST_CASE("_2p test optional 4") {
using namespace anyxx;
using namespace _2p_lib;
int v = 41;
optional<int&> a1{v};
static_assert(sizeof(a1) == sizeof(int*));
CHECK(a1.has_value());
CHECK(a1.get_value() == 41);
a1.get_value() = 42;
CHECK(v == 42);
static_assert(
!std::is_const_v<std::remove_reference_t<decltype(a1.get_value())>>);
CHECK(*a1 == 42);
auto a1x = a1;
CHECK(a1 == a1x);
CHECK(fun<optional<int&>>(a1, a1x));
int v1 = 42;
CHECK(a1 == optional<int&>{v1});
int v2 = 43;
CHECK(a1 != optional<int&>{v2});
CHECK(a1 != optional<int&>{});
optional<int&> a2;
CHECK(!a2.has_value());
CHECK(a2 == optional<int&>{});
}
C++ header only library for external polymorphism.