moving_ref committed with tests

Author: lefticus

include/lefticus/tools/moving_ref.hpp

@@ -0,0 +1,53 @@
+#ifndef LEFTICUS_TOOLS_MOVING_REF_HPP
+#define LEFTICUS_TOOLS_MOVING_REF_HPP
+
+#include <type_traits>
+#include <utility>
+
+namespace lefticus {
+
+
+#ifdef __cpp_concepts
+template<class P>
+struct DetectMoveConstruction
+{
+    constexpr operator P const&();
+    constexpr operator P&&();
+};
+
+template<typename T>
+concept copyable_xor_moveable = requires (T t, DetectMoveConstruction<T> m) {
+  // borrowed from https://stackoverflow.com/questions/51901837/how-to-get-if-a-type-is-truly-move-constructible/51912859#51912859
+  // if this line below compiles then we know we only have either
+  // a move assignment or a copy assignment, otherwise
+  // it would be ambiguous
+  // we cannot detect the constructor because MSVC
+  // seems to have a bug, but we can detect assignment!
+  t = m;
+};
+
+template<typename T>
+concept has_move_ctor = 
+  std::move_constructible<T> && !copyable_xor_moveable<T>;
+#endif
+
+
+
+#ifdef __cpp_concepts
+template<has_move_ctor T>
+#else
+template<typename T>
+#endif
+
+struct moving_ref {
+    constexpr moving_ref(T &&val) : ref{std::move(val)} {}
+    constexpr operator T&&() {
+        return std::move(ref);
+    }
+    T &&ref;
+};
+
+}
+
+#endif
+

test/CMakeLists.txt

@@ -83,7 +83,8 @@ add_constexpr_test_executables(
   simple_stack_string_tests.cpp
   flat_map_tests.cpp
   type_lists_tests.cpp
-  strong_types_tests.cpp)
+  strong_types_tests.cpp
+  moving_ref.cpp)
 target_link_libraries(
   "constexpr_tests"
   PRIVATE lefticus::tools
@@ -132,3 +133,4 @@ test_header_compiles(static_views.hpp)
 test_header_compiles(utility.hpp)
 test_header_compiles(strong_types.hpp)
 test_header_compiles(type_lists.hpp)
+test_header_compiles(moving_ref.hpp)

test/curry_tests.cpp

@@ -17,4 +17,5 @@ TEST_CASE("[curry] lambda")
   STATIC_REQUIRE(lefticus::tools::curry(func)(1, 2, 3) == 6);
   STATIC_REQUIRE(lefticus::tools::curry(func, 1)(2, 3) == 6);
   STATIC_REQUIRE(lefticus::tools::curry(func, 1, 2)(3) == 6);
+  STATIC_REQUIRE(lefticus::tools::curry(func, 1, 2, 3) == 6);
 }

test/moving_ref.cpp

@@ -0,0 +1,134 @@
+#include <catch2/catch.hpp>
+#include <lefticus/tools/moving_ref.hpp>
+
+#ifdef CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
+#define CONSTEXPR
+#else
+// NOLINTNEXTLINE
+#define CONSTEXPR constexpr
+#endif
+
+
+
+#include <string>
+
+
+struct CountsMovesCopies
+{
+  constexpr CountsMovesCopies() = default;
+  constexpr CountsMovesCopies(CountsMovesCopies &&other) noexcept {
+    ++other.move_constructed_from;
+  }
+  constexpr CountsMovesCopies(const CountsMovesCopies &other) noexcept {
+    ++other.copy_constructed_from;
+  }
+
+  constexpr CountsMovesCopies &operator=(CountsMovesCopies &&other) noexcept {
+    ++other.move_assigned_from;
+    return *this;
+  }
+
+  constexpr CountsMovesCopies &operator=(const CountsMovesCopies &other) noexcept {
+    ++other.copy_assigned_from;
+    return *this;
+  }
+
+  mutable int move_constructed_from = 0;
+  mutable int copy_constructed_from = 0;
+  mutable int move_assigned_from = 0;
+  mutable int copy_assigned_from = 0;
+
+};
+
+struct CopyOnlyType
+{
+  ~CopyOnlyType() = default;
+};
+
+
+
+template <typename T>
+constexpr auto can_construct_ref() {
+  return requires(T mct) {
+    lefticus::moving_ref<T>{std::move(mct)};
+  };
+}
+
+template <typename T>
+constexpr auto can_construct_ref_const() {
+  return requires(const T mct) {
+    lefticus::moving_ref<T>{std::move(mct)};
+  };
+}
+
+template <typename T>
+constexpr auto can_assign() {
+  return requires(T lhs, T mct) {
+    lhs = lefticus::moving_ref<T>{std::move(mct)};
+  };
+}
+
+
+template <typename T>
+constexpr auto can_assign_const() {
+  return requires(T lhs, const T mct) {
+    lhs = lefticus::moving_ref<T>{std::move(mct)};
+  };
+}
+
+template <typename T>
+constexpr auto can_construct() {
+  return requires(T mct) {
+    T{lefticus::moving_ref<T>{std::move(mct)}};
+  };
+}
+
+
+template <typename T>
+constexpr auto can_construct_const() {
+  return requires(const T mct) {
+    T{lefticus::moving_ref<T>{std::move(mct)}};
+  };
+}
+
+
+
+TEST_CASE("[moving_ref] behaves as expected")
+{
+  constexpr auto implicit_move = [](){
+    CountsMovesCopies cmc;
+    lefticus::moving_ref mr{std::move(cmc)};
+    [[maybe_unused]] CountsMovesCopies cmc2 = mr;
+
+    return cmc.move_constructed_from;
+  };
+
+  STATIC_REQUIRE(implicit_move() == 1);
+
+  constexpr auto implicit_move_assign = [](){
+    CountsMovesCopies cmc;
+    lefticus::moving_ref mr{std::move(cmc)};
+    CountsMovesCopies cmc2;
+    cmc2 = mr;
+
+    return cmc.move_assigned_from;
+  };
+
+  STATIC_REQUIRE(implicit_move_assign() == 1);
+
+  STATIC_REQUIRE(can_construct_ref<CountsMovesCopies>());
+  STATIC_REQUIRE(!can_construct_ref_const<CountsMovesCopies>());
+  STATIC_REQUIRE(can_assign<CountsMovesCopies>());
+  STATIC_REQUIRE(!can_assign_const<CountsMovesCopies>());
+  STATIC_REQUIRE(can_construct<CountsMovesCopies>());
+  STATIC_REQUIRE(!can_construct_const<CountsMovesCopies>());
+
+  STATIC_REQUIRE(!can_construct_ref<CopyOnlyType>());
+  STATIC_REQUIRE(!can_construct_ref_const<CopyOnlyType>());
+  STATIC_REQUIRE(!can_assign<CopyOnlyType>());
+  STATIC_REQUIRE(!can_assign_const<CopyOnlyType>());
+  STATIC_REQUIRE(!can_construct<CopyOnlyType>());
+  STATIC_REQUIRE(!can_construct_const<CopyOnlyType>());
+
+
+}