Merge pull request #27 from ignitionrobotics/implptr_get

Implptr Get function

include/ignition/utils/ImplPtr.hh

@@ -128,6 +128,18 @@ namespace ignition
       /// \return Immutable access to the contained object's members.
       public: const T *operator->() const;
 
+      /// \brief Non-const member access function. This const-unqualified
+      /// operator ensures that logical const-correctness is followed by the
+      /// consumer class.
+      /// \return Mutable access to the contained object's members.
+      public: T *Get();
+
+      /// \brief Const member access function. This const-qualified operator
+      /// ensures that logical const-correctness is followed by the consumer
+      /// class.
+      /// \return Immutable access to the contained object's members.
+      public: const T *Get() const;
+
       /// \internal \brief Create a clone of this ImplPtr's contents. This is
       /// for internal use only. The copy constructor and copy assignment
       /// operators should suffice for consumers.

include/ignition/utils/detail/ImplPtr.hh

@@ -30,6 +30,7 @@ namespace ignition
     {
       //////////////////////////////////////////////////
       template <class T, class CopyConstruct, class CopyAssign>
+      // cppcheck-suppress syntaxError
       template <class C, class A>
       CopyMoveDeleteOperations<T, CopyConstruct, CopyAssign>::
       CopyMoveDeleteOperations(C &&_construct, A &&_assign)
@@ -110,6 +111,20 @@ namespace ignition
       return ptr.get();
     }
 
+    //////////////////////////////////////////////////
+    template <class T, class Deleter, class Operations>
+    T *ImplPtr<T, Deleter, Operations>::Get()
+    {
+      return ptr.get();
+    }
+
+    //////////////////////////////////////////////////
+    template <class T, class Deleter, class Operations>
+    const T *ImplPtr<T, Deleter, Operations>::Get() const
+    {
+      return ptr.get();
+    }
+
     //////////////////////////////////////////////////
     template <class T, typename... Args>
     ImplPtr<T> MakeImpl(Args &&..._args)

test/integration/implptr/ImplPtr_TEST.cc

@@ -41,6 +41,25 @@ TEST(ImplPtr, CopyConstruct)
   EXPECT_EQ(object.GetString(), other.GetString());
 }
 
+/////////////////////////////////////////////////
+TEST(ImplPtr, GetAccessor)
+{
+  CopyableObject object(28, "golden_string");
+  int value = object.ThreadIncrementInt();
+  EXPECT_EQ(value, 1);
+  EXPECT_EQ(object.GetInt(), 1);
+
+  CopyableObject copied;
+  copied = object;
+  value = copied.ThreadIncrementInt();
+  EXPECT_EQ(value, 1);
+  EXPECT_EQ(copied.GetInt(), 1);
+
+  EXPECT_EQ(copied.ThreadIncrementInt(), object.ThreadIncrementInt());
+  EXPECT_EQ(copied.GetInt(), 1);
+  EXPECT_EQ(object.GetInt(), 1);
+}
+
 /////////////////////////////////////////////////
 TEST(ImplPtr, CopyAssign)
 {
@@ -111,6 +130,21 @@ TEST(UniqueImplPtr, MoveConstruct)
   EXPECT_EQ(other.GetString(), moved.GetString());
 }
 
+/////////////////////////////////////////////////
+TEST(UniqueImplPtr, GetAccessor)
+{
+  MovableObject object(28, "golden_string");
+  int value = object.ThreadIncrementInt();
+  EXPECT_EQ(value, 1);
+  EXPECT_EQ(object.GetInt(), 1);
+
+  MovableObject moved;
+  moved = std::move(object);
+  value = moved.ThreadIncrementInt();
+  EXPECT_EQ(value, 1);
+  EXPECT_EQ(moved.GetInt(), 1);
+}
+
 /////////////////////////////////////////////////
 TEST(UniqueImplPtr, MoveAssign)
 {

test/integration/implptr/implptr_test_classes.cc

@@ -18,12 +18,18 @@
 #include "implptr_test_classes.hh"
 
 #include <string>
+#include <thread>
 
 using namespace ignition;
 using namespace ignition::implptr_test_classes;
 
 class ignition::implptr_test_classes::ObjectPrivate
 {
+  public: void TestFunc()
+  {
+    this->ivalue += 1;
+  }
+
   public: int ivalue;
   public: std::string svalue;
 };
@@ -60,6 +66,15 @@ void CopyableObject::SetString(const std::string &_value)
   (*dataPtr).svalue = _value;
 }
 
+//////////////////////////////////////////////////
+int CopyableObject::ThreadIncrementInt()
+{
+  this->SetInt(0);
+  auto thread = std::thread(&ObjectPrivate::TestFunc, this->dataPtr.Get());
+  thread.join();
+  return this->GetInt();
+}
+
 //////////////////////////////////////////////////
 MovableObject::MovableObject(const int _ivalue, const std::string &_svalue)
   : dataPtr(utils::MakeUniqueImpl<ObjectPrivate>(_ivalue, _svalue))
@@ -91,6 +106,15 @@ void MovableObject::SetString(const std::string &_value)
   (*dataPtr).svalue = _value;
 }
 
+//////////////////////////////////////////////////
+int MovableObject::ThreadIncrementInt()
+{
+  this->SetInt(0);
+  auto thread = std::thread(&ObjectPrivate::TestFunc, this->dataPtr.get());
+  thread.join();
+  return this->GetInt();
+}
+
 //////////////////////////////////////////////////
 class CopyableObjectAlt::Implementation
 {

test/integration/implptr/implptr_test_classes.hh

@@ -21,6 +21,7 @@
 #include <ignition/utils/ImplPtr.hh>
 #include <ignition/utils/Export.hh>
 
+#include <functional>
 #include <string>
 
 namespace ignition
@@ -49,6 +50,11 @@ namespace ignition
       /// \brief Set the string value held by the pimpl
       public: void SetString(const std::string &_value);
 
+      /// \brief Uses a thread to increment the internal integer value from
+      /// 0 to 1.
+      /// \return The final internal integer value, which should be 1.
+      public: int ThreadIncrementInt();
+
       /// \brief Pointer to implementation
       /// This demonstrates using an implementation class that is
       /// forward-declared outside of this class.
@@ -74,6 +80,11 @@ namespace ignition
       /// \brief Set the string value held by the pimpl
       public: void SetString(const std::string &_value);
 
+      /// \brief Uses a thread to increment the internal integer value from
+      /// 0 to 1.
+      /// \return The final internal integer value, which should be 1.
+      public: int ThreadIncrementInt();
+
       /// \brief Pointer to implementation
       /// This demonstrates using an implementation class that is
       /// forward-declared outside of this class.