Expressions: Added transformedByDynamicCast

Author: JanosGit

include/vctr/Expressions/Generic/TransformedByDynamicCast.h

@@ -0,0 +1,63 @@
+/*
+  ==============================================================================
+    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+
+    Copyright 2025 by sonible GmbH.
+
+    This file is part of VCTR - Versatile Container Templates Reconceptualized.
+
+    VCTR is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    VCTR is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License version 3 for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
+  ==============================================================================
+*/
+
+namespace vctr::expressions
+{
+
+template <class T>
+concept isRefOrPtr = is::lvalueReference<T> || is::pointer<T>;
+
+template <size_t extent, class SrcType, isRefOrPtr DstValueType, is::constant ExpectCastToSucceed>
+class TransformedByDynamicCast : public ExpressionTemplateBase
+{
+public:
+    using value_type = DstValueType;
+
+    VCTR_COMMON_UNARY_EXPRESSION_MEMBERS (TransformedByDynamicCast, src)
+
+    VCTR_FORCEDINLINE constexpr DstValueType operator[] (size_t i) const
+    {
+        DstValueType casted = dynamic_cast<DstValueType> (src[i]);
+
+        if constexpr (is::pointer<ValueType<SrcType>> && ExpectCastToSucceed::value)
+            VCTR_ASSERT (casted != nullptr);
+
+        return casted;
+    }
+};
+
+} // namespace vctr::expressions
+
+namespace vctr
+{
+/** Transforms all source elements to DstValueType by applying a dynamic_cast<DstValueType> to them.
+
+    If expectCastToSucceed is true, then a VCTR_ASSERT will be inserted to ensure the dynamic cast
+    did not result in nullptr when casting pointers.
+
+    @ingroup Expressions
+ */
+template <class DstType, bool expectCastToSucceed = true>
+constexpr inline ExpressionChainBuilder<expressions::TransformedByDynamicCast, DstType, Constant<expectCastToSucceed>> transformedByDynamicCastTo;
+
+} // namespace vctr
+

include/vctr/TypeTraitsAndConcepts/GenericConcepts.h

@@ -87,7 +87,7 @@ concept triviallyCopyable = std::is_trivially_copyable_v<T>;
 template <class T>
 concept nonConst = ! std::is_const_v<T>;
 
-/** Constrains a type to be a pointer of a reference to a pointer */
+/** Constrains a type to be a pointer or a reference to a pointer */
 template <class T>
 concept pointer = std::is_pointer_v<std::remove_cvref_t<T>>;
 
@@ -99,6 +99,10 @@ concept noPointer = ! std::is_pointer_v<std::remove_cvref_t<T>>;
 template <class T>
 concept uniquePtr = detail::IsStdUniquePtr<T>::value;
 
+/** Constrains a type to be an lvalue reference */
+template <class T>
+concept lvalueReference = std::is_lvalue_reference_v<T>;
+
 /** Constrains the type to be any instance of std::tuple */
 template <class T>
 concept stdTuple = detail::IsStdTuple<T>::value;

include/vctr/vctr.h

@@ -158,6 +158,7 @@ VCTR_END_IGNORE_WARNING_MSVC
 
 #include "Expressions/Generic/Map.h"
 #include "Expressions/Generic/TransformedBy.h"
+#include "Expressions/Generic/TransformedByDynamicCast.h"
 #include "Expressions/Generic/TransformedByStaticCast.h"
 
 #include "Expressions/BasicMath/Abs.h"

test/TestCases/Expressions/Transformation.cpp

@@ -31,6 +31,51 @@ double toDoublePlus1 (T in) { return static_cast<double> (in + T (1)); }
 template <vctr::is::realNumber T>
 std::string toStringPlus1 (T in) { return std::to_string (in + T (1)); }
 
+TEST_CASE ("TransformedByDynamicCast", "[VCTR][transformation]")
+{
+    struct A
+    {
+        virtual ~A() = default;
+        int a;
+    };
+
+    struct B
+    {
+        virtual ~B() = default;
+        int b;
+    };
+
+    struct C : A, B
+    {
+        C (int x, int y)
+        {
+            a = x;
+            b = y;
+        }
+
+        ~C() override = default;
+    };
+
+    vctr::Array<B*, 2> bs { new C (1, 2), new C (3, 4) };
+
+    vctr::Array aPtrs = vctr::transformedByDynamicCastTo<A*> << bs;
+    vctr::Array aVals = vctr::transformedByStaticCastTo<A> << vctr::transformedByDynamicCastTo<A&> << vctr::transformedBy ([] (B* b)-> B& { return *b; }) << bs;
+
+    // The cast should have succeeded for all
+    REQUIRE (aPtrs.all ([] (A* a) { return a != nullptr; }));
+
+    REQUIRE (aPtrs[0]->a == 1);
+    REQUIRE (aPtrs[1]->a == 3);
+    REQUIRE (aVals[0].a == 1);
+    REQUIRE (aVals[1].a == 3);
+
+    // This cast should fail. Suppress assertion outputs for that case
+    vctr::Array invalid = vctr::transformedByDynamicCastTo<std::string*, false> << bs;
+    REQUIRE (invalid.allElementsEqual (nullptr));
+
+    bs.forEach ([] (B* b) { delete b; });
+}
+
 TEMPLATE_PRODUCT_TEST_CASE ("TransformedByStaticCast", "[VCTR][transformation]", (PlatformVectorOps, VCTR_NATIVE_SIMD), (float, double, int16_t, int32_t, int64_t))
 {
     VCTR_TEST_DEFINES (10)