IVGCVSW-4483 Introduce PolymorphicPointerDowncast

 * as replacement for boost::polymorphic_pointer_downcast
 * added PolymorphicPointerDowncast
 * added related unit test
 * added description to PolymorphicDowncast

Signed-off-by: Jan Eilers <jan.eilers@arm.com>
Change-Id: I47e94344c1c21941865549a5632cfb7cad804d35

diff --git a/include/armnn/utility/PolymorphicDowncast.hpp b/include/armnn/utility/PolymorphicDowncast.hpp
index b4a5cad..8f05237 100644 (file)
--- a/include/armnn/utility/PolymorphicDowncast.hpp
+++ b/include/armnn/utility/PolymorphicDowncast.hpp
@@ -9,6 +9,7 @@
 
 #include <armnn/Exceptions.hpp>
 
+#include <memory>
 #include <type_traits>
 
 namespace armnn
@@ -29,6 +30,46 @@ namespace armnn
 #endif
 
 
+namespace utility
+{
+// static_pointer_cast overload for std::shared_ptr
+template <class T1, class T2>
+std::shared_ptr<T1> StaticPointerCast (const std::shared_ptr<T2>& sp)
+{
+    return std::static_pointer_cast<T1>(sp);
+}
+
+// dynamic_pointer_cast overload for std::shared_ptr
+template <class T1, class T2>
+std::shared_ptr<T1> DynamicPointerCast (const std::shared_ptr<T2>& sp)
+{
+    return std::dynamic_pointer_cast<T1>(sp);
+}
+
+// static_pointer_cast overload for raw pointers
+template<class T1, class T2>
+inline T1* StaticPointerCast(T2 *ptr)
+{
+    return static_cast<T1*>(ptr);
+}
+
+// dynamic_pointer_cast overload for raw pointers
+template<class T1, class T2>
+inline T1* DynamicPointerCast(T2 *ptr)
+{
+    return dynamic_cast<T1*>(ptr);
+}
+
+} // namespace utility
+
+/// Polymorphic downcast for build in pointers only
+///
+/// Usage: Child* pChild = PolymorphicDowncast<Child*>(pBase);
+///
+/// \tparam DestType    Pointer type to the target object (Child pointer type)
+/// \tparam SourceType  Pointer type to the source object (Base pointer type)
+/// \param value        Pointer to the source object
+/// \return             Pointer of type DestType (Pointer of type child)
 template<typename DestType, typename SourceType>
 DestType PolymorphicDowncast(SourceType value)
 {
@@ -40,4 +81,21 @@ DestType PolymorphicDowncast(SourceType value)
     return static_cast<DestType>(value);
 }
 
+
+/// Polymorphic downcast for shared pointers and build in pointers
+///
+/// Usage: auto pChild = PolymorphicPointerDowncast<Child>(pBase)
+///
+/// \tparam DestType    Type of the target object (Child type)
+/// \tparam SourceType  Pointer type to the source object (Base (shared) pointer type)
+/// \param value        Pointer to the source object
+/// \return             Pointer of type DestType ((Shared) pointer of type child)
+template<typename DestType, typename SourceType>
+auto PolymorphicPointerDowncast(const SourceType& value)
+{
+    ARMNN_POLYMORPHIC_CAST_CHECK(utility::DynamicPointerCast<DestType>(value)
+                                 == utility::StaticPointerCast<DestType>(value));
+    return utility::StaticPointerCast<DestType>(value);
+}
+
 } //namespace armnn
\ No newline at end of file

diff --git a/src/armnn/test/UtilityTests.cpp b/src/armnn/test/UtilityTests.cpp
index d5779c1..af56364 100644 (file)
--- a/src/armnn/test/UtilityTests.cpp
+++ b/src/armnn/test/UtilityTests.cpp
@@ -5,7 +5,6 @@
 
 #include <boost/test/unit_test.hpp>
 #include <boost/core/lightweight_test.hpp>
-#include <boost/polymorphic_cast.hpp>
 
 #define ARMNN_POLYMORPHIC_CAST_TESTABLE
 #define ARMNN_NUMERIC_CAST_TESTABLE
@@ -56,6 +55,80 @@ BOOST_AUTO_TEST_CASE(PolymorphicDowncast)
 }
 
 
+BOOST_AUTO_TEST_CASE(PolymorphicPointerDowncast_SharedPointer)
+{
+    using namespace armnn;
+    class Base
+    {
+    public:
+        virtual ~Base(){}
+        float v;
+    };
+
+    class Child1 : public Base
+    {
+    public:
+        int j;
+    };
+
+    class Child2 : public Base
+    {
+    public:
+        char b;
+    };
+
+    std::shared_ptr<Base> base1 = std::make_shared<Child1>();
+
+    std::shared_ptr<Child1> ptr1 = std::static_pointer_cast<Child1>(base1);
+    BOOST_CHECK(ptr1);
+    BOOST_CHECK_NO_THROW(armnn::PolymorphicPointerDowncast<Child1>(base1));
+    BOOST_CHECK(armnn::PolymorphicPointerDowncast<Child1>(base1) == ptr1);
+
+    auto ptr2 = std::dynamic_pointer_cast<Child2>(base1);
+    BOOST_CHECK(!ptr2);
+    BOOST_CHECK_THROW(armnn::PolymorphicPointerDowncast<Child2>(base1), std::bad_cast);
+
+    armnn::IgnoreUnused(ptr1, ptr2);
+}
+
+
+BOOST_AUTO_TEST_CASE(PolymorphicPointerDowncast_BuildInPointer)
+{
+    using namespace armnn;
+    class Base
+    {
+    public:
+        virtual ~Base(){}
+        float v;
+    };
+
+    class Child1 : public Base
+    {
+    public:
+        int j;
+    };
+
+    class Child2 : public Base
+    {
+    public:
+        char b;
+    };
+
+    Child1 child1;
+    Base* base1 = &child1;
+    auto ptr1 = dynamic_cast<Child1*>(base1);
+    BOOST_CHECK(ptr1 != nullptr);
+    BOOST_CHECK_NO_THROW(armnn::PolymorphicPointerDowncast<Child1>(base1));
+    BOOST_CHECK(armnn::PolymorphicPointerDowncast<Child1>(base1) == ptr1);
+
+    auto ptr2 = dynamic_cast<Child2*>(base1);
+    BOOST_CHECK(ptr2 == nullptr);
+    BOOST_CHECK_THROW(armnn::PolymorphicPointerDowncast<Child2>(base1), std::bad_cast);
+
+    armnn::IgnoreUnused(ptr1, ptr2);
+}
+
+
 BOOST_AUTO_TEST_CASE(NumericCast)
 {
     using namespace armnn;