Changeset c6a59b for src/CodePatterns

Timestamp:

May 5, 2016, 1:06:20 PM (9 years ago)

Author:

Frederik Heber <heber@…>

Children:

c1e104

Parents:

039e15

git-author:

Frederik Heber <heber@…> (05/05/16 09:20:08)

git-committer:

Frederik Heber <heber@…> (05/05/16 13:06:20)

Message:

Singleton extended to also return AtomicInstance-wrapped instance.

Location:

src/CodePatterns

Files:

• Singleton.hpp (modified) (3 diffs)
• Singleton_impl.hpp (modified) (2 diffs)

src/CodePatterns/Singleton.hpp

@@ -17 +17 @@
 
 #include "CodePatterns/Assert.hpp"
+#include "CodePatterns/AtomicInstance.hpp"
 
 /**
@@ -145 +146 @@
    * when only the Singleton pattern is friend with the class
    *
-   * All methods have similar sematics to auto_ptr
+   * All methods have similar semantics to auto_ptr
    */
   class ptr_t {
@@ -235 +236 @@
 
   /**
+   * returns the instance of this Singleton as a reference inside a mutex-locked
+   * unique ptr.
+   *
+   * If no Singleton exists at this point and we are allowed to create one
+   * a new one is created and stored inside the singleton. If the mutex is locked,
+   * the function will wait until the mutex is released. This can be used to
+   * ensure atomic access to the static instance.
+   */
+  static AtomicInstance<T> getLockedInstance();
+
+  /**
    * returns the instance of this singleton as a pointer
    *

src/CodePatterns/Singleton_impl.hpp

@@ -45 +45 @@
   }
   return *theInstance;
+}
+
+template <class T,bool _may_create>
+AtomicInstance<T> Singleton<T,_may_create>::getLockedInstance(){
+  // boost supports RAII-Style locking, so we don't need to unlock
+  boost::recursive_mutex::scoped_lock guard(instanceLock);
+  if(!theInstance.get()) {
+    theInstance.reset(creator::make());
+  }
+  T *ptr = theInstance.get();
+  return AtomicInstance<T>(ptr);
 }
 
@@ -120 +131 @@
     template name& Singleton< name , name::may_create >::getInstance(); \
     template const name& Singleton< name , name::may_create >::getConstInstance(); \
+    template AtomicInstance<name> Singleton< name , name::may_create >::getLockedInstance(); \
     template name* Singleton< name , name::may_create >::getPointer();  \
     template const name* Singleton< name , name::may_create >::getConstPointer();  \