Merge pull request #45777 from Dr15Jones/concepts_RefToBase

Use C++ concepts in RefToBase

Author: cmsbuild

DataFormats/Common/interface/RefToBase.h

@@ -99,6 +99,11 @@ namespace edm {
     size_t key() const;
 
     template <class REF>
+      requires requires {
+        typename REF::value_type;
+        requires std::is_same_v<T, typename REF::value_type> or std::is_base_of_v<T, typename REF::value_type> or
+                     std::is_base_of_v<typename REF::value_type, T>;
+      }
     REF castTo() const;
 
     bool isNull() const;
@@ -228,43 +233,20 @@ namespace edm {
     return holder_->key();
   }
 
-  namespace {
-    // If the template parameters are classes or structs they should be
-    // related by inheritance, otherwise they should be the same type.
-    template <typename T, typename U>
-    typename std::enable_if<std::is_class<T>::value>::type checkTypeCompatibility() {
-      static_assert(std::is_base_of<T, U>::value || std::is_base_of<U, T>::value,
-                    "RefToBase::castTo error element types are not related by inheritance");
-    }
-
-    template <typename T, typename U>
-    typename std::enable_if<!std::is_class<T>::value>::type checkTypeCompatibility() {
-      static_assert(std::is_same<T, U>::value, "RefToBase::castTo error non-class element types are not the same");
-    }
-
-    // Convert the pointer types, use dynamic_cast if they are classes
-    template <typename T, typename OUT>
-    typename std::enable_if<std::is_class<T>::value, OUT const*>::type convertTo(T const* t) {
-      return dynamic_cast<OUT const*>(t);
-    }
-
-    template <typename T, typename OUT>
-    typename std::enable_if<!std::is_class<T>::value, OUT const*>::type convertTo(T const* t) {
-      return t;
-    }
-  }  // namespace
-
   template <class T>
   template <class REF>
+    requires requires {
+      typename REF::value_type;
+      requires std::is_same_v<T, typename REF::value_type> or std::is_base_of_v<T, typename REF::value_type> or
+                   std::is_base_of_v<typename REF::value_type, T>;
+    }
   REF RefToBase<T>::castTo() const {
     if (!holder_) {
       Exception::throwThis(errors::InvalidReference,
                            "attempting to cast a null RefToBase;\n"
                            "You should check for nullity before casting.");
     }
 
-    checkTypeCompatibility<T, typename REF::value_type>();
-
     // If REF is type edm::Ref<C,T,F>, then it is impossible to
     // check the container type C here. We just have to assume
     // that the caller provided the correct type.
@@ -278,7 +260,12 @@ namespace edm {
     if (value == nullptr) {
       return REF(id());
     }
-    typename REF::value_type const* newValue = convertTo<T, typename REF::value_type>(value);
+    typename REF::value_type const* newValue;
+    if constexpr (std::is_same_v<T, typename REF::value_type> or std::is_base_of_v<typename REF::value_type, T>) {
+      newValue = value;
+    } else {
+      newValue = dynamic_cast<typename REF::value_type const*>(value);
+    }
     if (newValue) {
       return REF(id(), newValue, key(), isTransient());
     }

DataFormats/Common/test/BuildFile.xml

@@ -11,10 +11,10 @@
 
 <test name="TestTriggerResultsFormat" command="TestTriggerResultsFormat.sh"/>
 
-<bin name="testDataFormatsCommon" file="testRunner.cpp,testOwnVector.cc,testOneToOneAssociation.cc,testValueMap.cc,testOneToManyAssociation.cc,testAssociationVector.cc,testAssociationNew.cc,testValueMapNew.cc,testSortedCollection.cc,testRangeMap.cc,ref_t.cppunit.cc,DetSetRefVector_t.cppunit.cc,reftobase_t.cppunit.cc,reftobasevector_t.cppunit.cc,cloningptr_t.cppunit.cc,ptr_t.cppunit.cc,ptrvector_t.cppunit.cc,containermask_t.cppunit.cc,reftobaseprod_t.cppunit.cc,handle_t.cppunit.cc">
+<bin name="testDataFormatsCommon" file="testRunner.cpp,testOwnVector.cc,testOneToOneAssociation.cc,testValueMap.cc,testOneToManyAssociation.cc,testAssociationVector.cc,testAssociationNew.cc,testValueMapNew.cc,testSortedCollection.cc,testRangeMap.cc,ref_t.cppunit.cc,DetSetRefVector_t.cppunit.cc,reftobasevector_t.cppunit.cc,cloningptr_t.cppunit.cc,ptr_t.cppunit.cc,ptrvector_t.cppunit.cc,containermask_t.cppunit.cc,reftobaseprod_t.cppunit.cc,handle_t.cppunit.cc">
 </bin>
 
-<bin name="testDataFormatsCommonCatch2" file="DetSetVector_t.cpp,exDSTV.cpp,exTrie.cpp,OwnVector_t.cpp,Wrapper_t.cpp,testBoostRange.cpp">
+<bin name="testDataFormatsCommonCatch2" file="DetSetVector_t.cpp,exDSTV.cpp,exTrie.cpp,OwnVector_t.cpp,Wrapper_t.cpp,testBoostRange.cpp,reftobase_t.cpp,">
 <use name="catch2"/>
 </bin>
 

DataFormats/Common/test/reftobase_t.cpp

@@ -0,0 +1,92 @@
+#include "catch.hpp"
+
+#include "DataFormats/Common/interface/RefToBase.h"
+#include "DataFormats/Common/interface/Ref.h"
+#include "DataFormats/Common/interface/TestHandle.h"
+
+#include <vector>
+
+namespace testreftobase {
+  struct Base {
+    virtual ~Base() {}
+    virtual int val() const = 0;
+  };
+
+  struct Inherit1 : public Base {
+    virtual int val() const { return 1; }
+  };
+  struct Inherit2 : public Base {
+    virtual int val() const { return 2; }
+  };
+}  // namespace testreftobase
+
+using namespace testreftobase;
+
+TEST_CASE("test RefToBase", "[RefToBase]") {
+  SECTION("Class type") {
+    using namespace edm;
+
+    std::vector<Inherit1> v1(2, Inherit1());
+
+    TestHandle<std::vector<Inherit1> > h1(&v1, ProductID(1, 1));
+    Ref<std::vector<Inherit1> > r1(h1, 1);
+    RefToBase<Base> b1(r1);
+
+    SECTION("Value check") {
+      CHECK(&(*b1) == static_cast<Base*>(&(v1[1])));
+      CHECK(b1.operator->() == b1.get());
+      CHECK(b1.get() == static_cast<Base*>(&(v1[1])));
+      CHECK(b1.id() == ProductID(1, 1));
+    }
+    SECTION("Copy constructor") {
+      //copy constructor
+      RefToBase<Base> b2(b1);
+      CHECK(&(*b2) == static_cast<Base*>(&(v1[1])));
+      CHECK(b2.id() == b1.id());
+    }
+
+    SECTION("operator=") {
+      //operator=
+      RefToBase<Base> b3;
+      CHECK(b3.isNull());
+      CHECK(!(b3.isNonnull()));
+      CHECK(!b3);
+      b3 = b1;
+      CHECK(&(*b3) == static_cast<Base*>(&(v1[1])));
+      CHECK(b3.id() == b1.id());
+      CHECK(!(b3.isNull()));
+      CHECK(b3.isNonnull());
+      CHECK(!(!b3));
+    }
+
+    SECTION("castTo inheriting type") { CHECK(b1.castTo<Ref<std::vector<Inherit1> > >() == r1); }
+    SECTION("castTo incorrect inherting type") {
+      CHECK_THROWS_AS(b1.castTo<Ref<std::vector<Inherit2> > >(), cms::Exception);
+    }
+    /*
+    Uncomment to test compile time failure
+    SECTION("castTo unrelated type") {
+      b1.castTo<Ref<std::vector<std::string> > >();
+    } */
+  }
+
+  SECTION("builtin type") {
+    using namespace edm;
+    std::vector<int> v1(2, 3);
+
+    TestHandle<std::vector<int> > h1(&v1, ProductID(1, 1));
+    Ref<std::vector<int> > r1(h1, 1);
+    RefToBase<int> b1(r1);
+
+    SECTION("Value check") {
+      CHECK(&(*b1) == &v1[1]);
+      CHECK(b1.operator->() == b1.get());
+      CHECK(b1.get() == (&(v1[1])));
+      CHECK(b1.id() == ProductID(1, 1));
+    }
+    SECTION("castTo Ref") { CHECK(b1.castTo<Ref<std::vector<int> > >() == r1); }
+    /* uncomment to test compile time failure
+    SECTION("bad castTo Ref") { b1.castTo<Ref<std::vector<double> > >(); }
+    */
+  }
+}