first release.

Author: xhawk18

CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(singleton-cpp)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+set(CMAKE_EXECUTABLE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY  "${CMAKE_BINARY_DIR}/bin")
+
+add_subdirectory(./src)
+add_subdirectory(./example)

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 xhawk18 -at- gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Readme.md

@@ -0,0 +1,25 @@
+## Singleton for cpp
+
+Features --
+
+1. Works for both dynamical library and executable.
+2. Multithread safe
+3. Lazy consturction
+
+## Usage
+
+1. define a class or struct, for example
+
+```
+class MyObject {
+public:
+    int a;
+    int b;
+};
+```
+
+2. use the singleton instance
+
+```
+    MyObject &obj = singleton<MyObject>();
+```

example/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(singleton-cpp-exmaple C CXX)
+enable_language(C CXX)
+
+set(my_headers
+    ../include/singleton-cpp/singleton.h
+    ./my_dll.h
+    ./my_dll_api.h
+)
+
+set(my_includes
+    ../include
+)
+
+add_library(my_dll SHARED my_dll.cpp ${my_headers})
+target_include_directories(my_dll PRIVATE ${my_includes})
+target_link_libraries(my_dll singleton)
+
+
+add_executable(my_exe my_exe.cpp ${my_headers})
+target_include_directories(my_exe PRIVATE ${my_includes})
+target_link_libraries(my_exe singleton my_dll)

example/my_dll.cpp

@@ -0,0 +1,12 @@
+#include "my_dll.h"
+#include "singleton-cpp/singleton.h"
+
+MY_DLL_API void setValue() {
+
+    MyObject0 &obj0 = singleton<MyObject0>();
+    obj0.a = 3;
+    obj0.b = 4;
+
+    MyObject1 &obj1 = singleton<MyObject1>();
+    obj1.c = "test1234";
+}

example/my_dll.h

@@ -0,0 +1,23 @@
+#pragma once
+#ifndef INC_MY_DLL_H_
+#define INC_MY_DLL_H_
+
+#include "my_dll_api.h"
+#include <string>
+
+class MyObject0 {
+public:
+    int a;
+    int b;
+};
+
+class MyObject1 {
+public:
+    std::string c;
+};
+
+
+MY_DLL_API void setValue();
+
+
+#endif

example/my_dll_api.h

@@ -0,0 +1,34 @@
+#pragma once
+#ifndef INC_MY_DLL_API_H_
+#define INC_MY_DLL_API_H_
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  if defined(my_dll_EXPORTS) // add by CMake 
+#    ifdef __GNUC__
+#      define  MY_DLL_API __attribute__(dllexport)
+#    else
+#      define  MY_DLL_API __declspec(dllexport)
+#    endif
+#  else
+#    ifdef __GNUC__
+#      define  MY_DLL_API __attribute__(dllimport)
+#    else
+#      define  MY_DLL_API __declspec(dllimport)
+#    endif
+#  endif // my_dll_EXPORTS
+
+#elif defined __GNUC__
+#  if __GNUC__ >= 4
+#    define MY_DLL_API __attribute__ ((visibility ("default")))
+#  else
+#    define MY_DLL_API
+#  endif
+
+#elif defined __clang__
+#  define MY_DLL_API __attribute__ ((visibility ("default")))
+
+#else
+#   error "Do not know how to export classes for this platform"
+#endif
+
+#endif

example/my_exe.cpp

@@ -0,0 +1,16 @@
+#include "my_dll.h"
+#include "singleton-cpp/singleton.h"
+
+int main() {
+    // set value in dll
+    setValue();
+
+    // get value from exe
+    MyObject0 &obj0 = singleton<MyObject0>();
+    printf("%d %d\n", obj0.a, obj0.b);
+
+    MyObject1 &obj1 = singleton<MyObject1>();
+    printf("%s\n", obj1.c.c_str());
+
+    return 0;
+}

include/singleton-cpp/singleton.h

@@ -0,0 +1,89 @@
+#pragma once
+#ifndef INC_SINGLETON_H_
+#define INC_SINGLETON_H_
+
+#include <mutex>
+#include <typeindex>
+#include <memory>
+#include "singleton_api.h"
+
+// Singleton mode for cpp
+// 
+// Features --
+//   1. Works for both dynamical library and executable.
+//   2. Multithread safe
+//   3. Lazy consturction
+
+template<typename T>
+class Singleton;
+
+// Get singleton instance
+template<typename T>
+inline T &singleton() {
+    return Singleton<T>::getInstance();
+}
+
+
+struct SingleTonHolder {
+    void *object_;
+    std::shared_ptr<std::mutex> mutex_;
+};
+
+SINGLETON_API std::mutex &getSingleTonMutex();
+SINGLETON_API SingleTonHolder *getSingleTonType(const std::type_index &typeIndex);
+
+
+template<typename T>
+class Singleton {
+public:
+    // Get the single instance
+    static T &getInstance() {
+        return *getInstancePrivate();
+    }
+
+private:
+    // Get the single instance
+    static T *getInstancePrivate() {
+        static T *instance = nullptr;
+        if (instance != nullptr)
+            return instance;
+
+        SingleTonHolder *singleTonHolder = nullptr;
+        {
+            // Locks and get the global mutex
+            std::lock_guard<std::mutex> myLock(getSingleTonMutex());
+            if (instance != nullptr)
+                return instance;
+
+            singleTonHolder = getSingleTonType(std::type_index(typeid(T)));
+        }
+
+        // Create single instance
+        T *instanceFromHolder = createInstanceFromHolder(singleTonHolder);
+
+        {
+            // Save single instance object
+            std::lock_guard<std::mutex> myLock(getSingleTonMutex());
+            instance = instanceFromHolder;
+            return instance;
+        }
+    }
+
+    static T *createInstanceFromHolder(SingleTonHolder *singleTonHolder) {
+        // Locks class T and make sure to call construction only once
+        std::lock_guard<std::mutex> myLock(*singleTonHolder->mutex_);
+        if (singleTonHolder->object_ == nullptr) {
+            // construct the instance with static funciton
+            singleTonHolder->object_ = reinterpret_cast<void *>(getStaticInstance());
+        }
+        return reinterpret_cast<T *>(singleTonHolder->object_);
+    }
+
+    static T *getStaticInstance() {
+        static T t;
+        return &t;
+    }
+};
+
+
+#endif

include/singleton-cpp/singleton_api.h

@@ -0,0 +1,34 @@
+#pragma once
+#ifndef INC_SINGLETON_API_H_
+#define INC_SINGLETON_API_H_
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  if defined(singleton_EXPORTS) // add by CMake 
+#    ifdef __GNUC__
+#      define  SINGLETON_API __attribute__(dllexport)
+#    else
+#      define  SINGLETON_API __declspec(dllexport)
+#    endif
+#  else
+#    ifdef __GNUC__
+#      define  SINGLETON_API __attribute__(dllimport)
+#    else
+#      define  SINGLETON_API __declspec(dllimport)
+#    endif
+#  endif // singleton_EXPORTS
+
+#elif defined __GNUC__
+#  if __GNUC__ >= 4
+#    define SINGLETON_API __attribute__ ((visibility ("default")))
+#  else
+#    define SINGLETON_API
+#  endif
+
+#elif defined __clang__
+#  define SINGLETON_API __attribute__ ((visibility ("default")))
+
+#else
+#   error "Do not know how to export classes for this platform"
+#endif
+
+#endif