Merge lp:~michihenning/unity-api/defines-ptrs into lp:unity-api

[Michi Henning]

Changed DefinesPtrs to a macro. That way, we don't need a virtual destructor, and the generated typedefs can be used with POD types. The macro also prevents ambiguous names that were caused by the template for classes in a derivation hierarchy.

Changed DefinesPtrs to a macro. That way, we don't need a virtual destructor, and the generated typedefs can be used with POD types. The macro also prevents ambiguous names that were caused by the template for classes in a derivation hierarchy.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:78
http://jenkins.qa.ubuntu.com/job/unity-api-ci/106/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-saucy-armhf-ci/63
        deb: http://jenkins.qa.ubuntu.com/job/unity-api-saucy-armhf-ci/63/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-api-saucy-i386-ci/64

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-api-ci/106/rebuild

review: Approve (continuous-integration)

[Michi Henning (michihenning)]

Top-approving this because Jussi and I discussed this change previously. Jussi, when you are back, please raise any issues you see that I've missed!

=== modified file 'include/unity/util/Daemon.h'
--- include/unity/util/Daemon.h	2013-06-26 23:47:34 +0000
+++ include/unity/util/Daemon.h	2013-07-23 00:55:32 +0000
@@ -63,9 +63,13 @@
 Note: This class is not async signal-safe. Do not call daemonize_me() from a a signal handler.
 */
 
-class UNITY_API Daemon final : public util::DefinesPtrs<Daemon>, private NonCopyable
+class UNITY_API Daemon final : private NonCopyable
 {
 public:
+    /// @cond
+    UNITY_DEFINES_PTRS(Daemon);
+    /// @endcond
+
     /**
     \brief Create a Daemon instance.
     \return A <code>unique_ptr</code> to the instance.

=== modified file 'include/unity/util/DefinesPtrs.h'
--- include/unity/util/DefinesPtrs.h	2013-06-26 23:47:34 +0000
+++ include/unity/util/DefinesPtrs.h	2013-07-23 00:55:32 +0000
@@ -21,25 +21,21 @@
 
 #include <memory>
 
-namespace unity
-{
-
-namespace util
-{
-
 /**
-\brief Helper template to inject smart pointer definitions into a class.
+\file DefinesPtrs.h
+\def UNITY_DEFINES_PTRS(classname)
+\brief Macro to add smart pointer definitions to a class.
 
-This template injects type definitions for smart pointer types into a class. It is useful to
+This macro injects type definitions for smart pointer types into a class. It is useful to
 establish a common naming convention for smart pointers across a project.
 
-You can use the template as follows. Note that the template parameter is the name of the class
-being defined ("curiously recurring template pattern").
+You can use the macro as follows. Note that the macro argument is the name of the class being defined.
 
 ~~~
-* class MyClass : public util::DefinesPtrs<MyClass>
+* class MyClass
 * {
 * public:
+*     UNITY_DEFINES_PTRS(MyClass);
 *     // MyClass now provides public typedefs for SPtr, SCPtr, UPtr, and UCPtr.
 *     // ...
 * };
@@ -53,37 +49,10 @@
 
 */
 
-template <typename T>
-class DefinesPtrs
-{
-public:
-    /**
-    A <code>std::shared_ptr</code> to a non-constant instance.
-    */
-    typedef std::shared_ptr<T> SPtr;
-
-    /**
-    A <code>std::shared_ptr</code> to a constant instance.
-    */
-    typedef std::shared_ptr<T const> SCPtr;
-
-    /**
-    A <code>std::unique_ptr</code> to a non-constant instance.
-    */
-    typedef std::unique_ptr<T> UPtr;
-
-    /**
-    A <code>std::unique_ptr</code> to a constant instance.
-    */
-    typedef std::unique_ptr<T const> UCPtr;
-
-protected:                                  // Not meant to be instantiated stand-alone
-    DefinesPtrs() = default;
-    virtual ~DefinesPtrs() = default;
-};
-
-} // namespace util
-
-} // namespace unity
+#define UNITY_DEFINES_PTRS(classname)               \
+    typedef std::shared_ptr<classname>       SPtr;  \
+    typedef std::shared_ptr<classname const> SCPtr; \
+    typedef std::unique_ptr<classname>       UPtr;  \
+    typedef std::unique_ptr<classname const> UCPtr
 
 #endif

=== modified file 'test/gtest/unity/util/DefinesPtrs/DefinesPtrs_test.cpp'
--- test/gtest/unity/util/DefinesPtrs/DefinesPtrs_test.cpp	2013-06-26 23:47:34 +0000
+++ test/gtest/unity/util/DefinesPtrs/DefinesPtrs_test.cpp	2013-07-23 00:55:32 +0000
@@ -23,23 +23,42 @@
 
 using namespace unity::util;
 
-class MyClass : public DefinesPtrs<MyClass>, private NonCopyable
+class MyClass : private NonCopyable
 {
 public:
+    UNITY_DEFINES_PTRS(MyClass);
+
     static SPtr create()
     {
         return SPtr(new MyClass);
     }
 
-private:
+protected:
     MyClass()
     {
     }
 };
 
+class MyDerivedClass : public MyClass
+{
+public:
+    UNITY_DEFINES_PTRS(MyDerivedClass);
+
+    static UPtr create()
+    {
+        return UPtr(new MyDerivedClass);
+    }
+
+protected:
+    MyDerivedClass()
+    {
+    }
+};
+
 TEST(DefinesPtrs, basic)
 {
-    // No real test here. This is just so we get function coverage for the coverage tests.
+    // No real test here. This is just so we check that things compile.
 
     MyClass::SPtr p = MyClass::create();
+    MyDerivedClass::UPtr q = MyDerivedClass::create();
 }