fix failing checks

- core.cxx_gsl aktualisiert auf [](https://gitlab.avm.de/fos/repos/core.cxx_gsl/-/commit/)
- plc.access_lib aktualisiert auf [](https://gitlab.avm.de/fos/repos/plc.access_lib/-/commit/)
- plc.common aktualisiert auf [](https://gitlab.avm.de/fos/repos/plc.common/-/commit/)
- plc.daemon aktualisiert auf [](https://gitlab.avm.de/fos/repos/plc.daemon/-/commit/)
-

Test Plan:
-

tests/byte_tests.cpp

@@ -131,40 +131,46 @@ TEST(byte_tests, aliasing)
     EXPECT_TRUE(res == i);
 }
 
-//  These are regressions, should be fixed.
+#if __cplusplus >= 201703l
+using std::void_t;
+#else  // __cplusplus >= 201703l
+template <class...>
+using void_t = void;
+#endif // __cplusplus < 201703l
+
 template <typename U, typename = void>
 static constexpr bool LShiftCompilesFor = false;
 template <typename U>
 static constexpr bool LShiftCompilesFor<
-    U, std::void_t<decltype(gsl::operator<< <float>(declval<gsl::byte>(), declval<U>()))>> = true;
+    U, void_t<decltype(gsl::operator<< <float>(declval<gsl::byte>(), declval<U>()))>> = true;
 static_assert(!LShiftCompilesFor<float>, "!LShiftCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool RShiftCompilesFor = false;
 template <typename U>
 static constexpr bool RShiftCompilesFor<
-    U, std::void_t<decltype(gsl::operator>> <U>(declval<gsl::byte>(), declval<U>()))>> = true;
+    U, void_t<decltype(gsl::operator>> <U>(declval<gsl::byte>(), declval<U>()))>> = true;
 static_assert(!RShiftCompilesFor<float>, "!RShiftCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool LShiftAssignCompilesFor = false;
 template <typename U>
 static constexpr bool LShiftAssignCompilesFor<
-    U, std::void_t<decltype(gsl::operator<<= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
+    U, void_t<decltype(gsl::operator<<= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
 static_assert(!LShiftAssignCompilesFor<float>, "!LShiftAssignCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool RShiftAssignCompilesFor = false;
 template <typename U>
 static constexpr bool RShiftAssignCompilesFor<
-    U, std::void_t<decltype(gsl::operator>>= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
+    U, void_t<decltype(gsl::operator>>= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
 static_assert(!RShiftAssignCompilesFor<float>, "!RShiftAssignCompilesFor<float>");
 
 template <typename U, typename = void>
 static constexpr bool ToIntegerCompilesFor = false;
 template <typename U>
 static constexpr bool
-    ToIntegerCompilesFor<U, std::void_t<decltype(gsl::to_integer<U>(gsl::byte{}))>> = true;
+    ToIntegerCompilesFor<U, void_t<decltype(gsl::to_integer<U>(gsl::byte{}))>> = true;
 static_assert(!ToIntegerCompilesFor<float>, "!ToIntegerCompilesFor<float>");
 
 } // namespace

tests/pointers_tests.cpp

@@ -8,6 +8,19 @@
 
 namespace
 {
+// Custom pointer type that can be used for gsl::not_null, but for which these cannot be swapped.
+struct NotMoveAssignableCustomPtr
+{
+    NotMoveAssignableCustomPtr() = default;
+    NotMoveAssignableCustomPtr(const NotMoveAssignableCustomPtr&) = default;
+    NotMoveAssignableCustomPtr& operator=(const NotMoveAssignableCustomPtr&) = default;
+    NotMoveAssignableCustomPtr(NotMoveAssignableCustomPtr&&) = default;
+    NotMoveAssignableCustomPtr& operator=(NotMoveAssignableCustomPtr&&) = delete;
+
+    bool operator!=(std::nullptr_t) const { return true; }
+
+    int dummy{}; // Without this clang warns, that NotMoveAssignableCustomPtr() is unneeded
+};
 
 TEST(pointers_test, swap)
 {
@@ -22,21 +35,28 @@ TEST(pointers_test, swap)
 
     EXPECT_TRUE(*a == 1);
     EXPECT_TRUE(*b == 0);
+
+    // Make sure our custom ptr can be used with not_null. The shared_pr is to prevent "unused"
+    // compiler warnings.
+    const auto shared_custom_ptr{std::make_shared<NotMoveAssignableCustomPtr>()};
+    gsl::not_null<NotMoveAssignableCustomPtr> c{*shared_custom_ptr};
+    EXPECT_TRUE(c.get() != nullptr);
 }
 
-//  These are regressions, should be fixed.
+#if __cplusplus >= 201703l
-struct NotMovable
+using std::void_t;
-{
+#else  // __cplusplus >= 201703l
-    NotMovable(NotMovable&&) = delete;
+template <class...>
-    NotMovable& operator=(NotMovable&&) = delete;
+using void_t = void;
-};
+#endif // __cplusplus < 201703l
+
 template <typename U, typename = void>
 static constexpr bool SwapCompilesFor = false;
 template <typename U>
 static constexpr bool
-    SwapCompilesFor<U, std::void_t<decltype(gsl::swap<U>(std::declval<gsl::not_null<U>&>(),
+    SwapCompilesFor<U, void_t<decltype(gsl::swap<U>(std::declval<gsl::not_null<U>&>(),
-                                                         std::declval<gsl::not_null<U>&>()))>> =
+                                                    std::declval<gsl::not_null<U>&>()))>> = true;
-        true;
+static_assert(!SwapCompilesFor<NotMoveAssignableCustomPtr>,
-static_assert(!SwapCompilesFor<NotMovable>, "!SwapCompilesFor<NotMovable>");
+              "!SwapCompilesFor<NotMoveAssignableCustomPtr>");
 
 } // namespace

tests/span_compatibility_tests.cpp

@@ -1005,12 +1005,18 @@ static_assert(std::is_convertible<const std::array<int, 3>&, gsl::span<const int
               "std::is_convertible<const std::array<int, 3>&, gsl::span<const int>>");
 
 #if __cplusplus >= 201703l
+using std::void_t;
+#else  // __cplusplus >= 201703l
+template <class...>
+using void_t = void;
+#endif // __cplusplus < 201703l
+
 template <typename U, typename = void>
 static constexpr bool AsWritableBytesCompilesFor = false;
 
 template <typename U>
 static constexpr bool
-    AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(declval<U>()))>> = true;
+    AsWritableBytesCompilesFor<U, ::void_t<decltype(as_writable_bytes(declval<U>()))>> = true;
 
 static_assert(AsWritableBytesCompilesFor<gsl::span<int>>,
               "AsWritableBytesCompilesFor<gsl::span<int>>");
@@ -1020,4 +1026,3 @@ static_assert(!AsWritableBytesCompilesFor<gsl::span<const int>>,
               "!AsWritableBytesCompilesFor<gsl::span<const int>>");
 static_assert(!AsWritableBytesCompilesFor<gsl::span<const int, 9>>,
               "!AsWritableBytesCompilesFor<gsl::span<const int, 9>>");
-#endif // __cplusplus >= 201703l