Skip to content

Commit

Permalink
Modernize type traits
Browse files Browse the repository at this point in the history
  • Loading branch information
@falbrechtskirchinger @Flow86
falbrechtskirchinger authored and Flow86 committed Aug 7, 2023
1 parent 4fd7c81 commit 31c1312
Show file tree
Hide file tree
Showing 3 changed files with 32 additions and 29 deletions.
7 changes: 5 additions & 2 deletions include/libsiedler2/ICloneable.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,14 +19,17 @@ namespace detail {
struct is_static_castable<T, U, decltype(void(static_cast<U>(std::declval<T>())))> : std::true_type
{};

template<typename T, typename U>
inline constexpr bool is_static_castable_v = is_static_castable<T, U>::value;

template<typename To, typename From>
std::enable_if_t<is_static_castable<From*, To*>::value, To*> safePtrCast(From* from)
std::enable_if_t<is_static_castable_v<From*, To*>, To*> safePtrCast(From* from)
{
return static_cast<To*>(from);
}

template<typename To, typename From>
std::enable_if_t<!is_static_castable<From*, To*>::value, To*> safePtrCast(From* from)
std::enable_if_t<!is_static_castable_v<From*, To*>, To*> safePtrCast(From* from)
{
return dynamic_cast<To*>(from);
}
Expand Down
8 changes: 4 additions & 4 deletions tests/testArchiv.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -159,10 +159,10 @@ struct TestItem : libsiedler2::ArchivItem
RTTR_CLONEABLE(TestItem)
};

static_assert(!std::is_copy_constructible<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
static_assert(!std::is_move_constructible<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
static_assert(!std::is_copy_assignable<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
static_assert(!std::is_move_assignable<libsiedler2::ArchivItem>::value, "Should not be Copyable/Movable");
static_assert(!std::is_copy_constructible_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
static_assert(!std::is_move_constructible_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
static_assert(!std::is_copy_assignable_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");
static_assert(!std::is_move_assignable_v<libsiedler2::ArchivItem>, "Should not be Copyable/Movable");

int TestItem::numLiveItems = 0;

Expand Down
46 changes: 23 additions & 23 deletions tests/testClone.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,36 +34,36 @@ struct Bar : virtual BarBase
using TestedTypes = boost::mpl::list<Foo, Bar>;
} // namespace

static_assert(detail::is_static_castable<int, int>::value);
static_assert(detail::is_static_castable<int, float>::value);
static_assert(detail::is_static_castable<int*, const int*>::value);
static_assert(!detail::is_static_castable<const int*, int*>::value);
static_assert(detail::is_static_castable_v<int, int>);
static_assert(detail::is_static_castable_v<int, float>);
static_assert(detail::is_static_castable_v<int*, const int*>);
static_assert(!detail::is_static_castable_v<const int*, int*>);

static_assert(detail::is_static_castable<Foo*, Foo*>::value);
static_assert(detail::is_static_castable<Foo*, const Foo*>::value);
static_assert(!detail::is_static_castable<const Foo*, Foo*>::value);
static_assert(detail::is_static_castable<Foo*, Base*>::value);
static_assert(detail::is_static_castable<Foo*, const Base*>::value);
static_assert(detail::is_static_castable<Base*, Foo*>::value);
static_assert(!detail::is_static_castable<const Base*, Foo*>::value);
static_assert(detail::is_static_castable_v<Foo*, Foo*>);
static_assert(detail::is_static_castable_v<Foo*, const Foo*>);
static_assert(!detail::is_static_castable_v<const Foo*, Foo*>);
static_assert(detail::is_static_castable_v<Foo*, Base*>);
static_assert(detail::is_static_castable_v<Foo*, const Base*>);
static_assert(detail::is_static_castable_v<Base*, Foo*>);
static_assert(!detail::is_static_castable_v<const Base*, Foo*>);

static_assert(detail::is_static_castable<BarBase*, Base*>::value);
static_assert(detail::is_static_castable<Base*, BarBase*>::value);
static_assert(detail::is_static_castable<Bar*, BarBase*>::value);
static_assert(detail::is_static_castable<Bar*, Base*>::value);
static_assert(detail::is_static_castable_v<BarBase*, Base*>);
static_assert(detail::is_static_castable_v<Base*, BarBase*>);
static_assert(detail::is_static_castable_v<Bar*, BarBase*>);
static_assert(detail::is_static_castable_v<Bar*, Base*>);
// Virtual inheritance -> no base to derived cast
static_assert(!detail::is_static_castable<Base*, Bar*>::value);
static_assert(!detail::is_static_castable<BarBase*, Bar*>::value);
static_assert(!detail::is_static_castable_v<Base*, Bar*>);
static_assert(!detail::is_static_castable_v<BarBase*, Bar*>);

BOOST_AUTO_TEST_CASE_TEMPLATE(CloneWorks, T, TestedTypes)
{
auto f = std::make_unique<T>(42);
auto f2 = clone(f); // By unique_ptr
auto f3 = clone(f.get()); // By raw ptr
auto f4 = clone(*f); // By reference
static_assert(std::is_same<decltype(f2), decltype(f)>::value, "Must be the same");
static_assert(std::is_same<decltype(f3), decltype(f)>::value, "Must be the same");
static_assert(std::is_same<decltype(f4), decltype(f)>::value, "Must be the same");
static_assert(std::is_same_v<decltype(f2), decltype(f)>, "Must be the same");
static_assert(std::is_same_v<decltype(f3), decltype(f)>, "Must be the same");
static_assert(std::is_same_v<decltype(f4), decltype(f)>, "Must be the same");
BOOST_TEST((f && f2 && f3 && f4));
BOOST_TEST(f->i == 42);
BOOST_TEST(f2->i == 42);
Expand All @@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(CloneFromBasePtr)
auto f = std::make_unique<Bar>(42, 1337);
auto* basePtr = static_cast<BarBase*>(f.get());
auto f2 = clone(basePtr);
static_assert(std::is_same<decltype(f2), std::unique_ptr<BarBase>>::value, "Must be the same");
static_assert(std::is_same_v<decltype(f2), std::unique_ptr<BarBase>>, "Must be the same");
BOOST_TEST((f && f2 && basePtr));
BOOST_TEST(f->i == 42);
BOOST_TEST(f->j == 1337);
Expand All @@ -89,8 +89,8 @@ BOOST_AUTO_TEST_CASE(CloneNull)
std::unique_ptr<Foo> f;
auto f2 = clone(f); // By unique_ptr
auto f3 = clone(f.get()); // By raw ptr
static_assert(std::is_same<decltype(f2), decltype(f)>::value, "Must be the same");
static_assert(std::is_same<decltype(f3), decltype(f)>::value, "Must be the same");
static_assert(std::is_same_v<decltype(f2), decltype(f)>, "Must be the same");
static_assert(std::is_same_v<decltype(f3), decltype(f)>, "Must be the same");
BOOST_TEST(!f2);
BOOST_TEST(!f3);
}

0 comments on commit 31c1312

Please sign in to comment.