import std_call_once_bug/ from gh-pages

I rewrote this repository's history completely in an attempt to organize
things properly.
One of those things is moving code to master.
I couldn't figure out how to preserve the history though.
Luckily, it's a very small code sample.

4 files changed, 259 insertions, 0 deletions

diff --git a/common.cmake b/common.cmake
new file mode 100644
index 0000000..d719542
--- /dev/null
+++ b/common.cmake
@@ -0,0 +1,96 @@
+# Copyright (c) 2017 Egor Tensin <Egor.Tensin@gmail.com>
+# It's a CMake code snippet I use in all of my CMake projects.
+# It makes targets link the runtime statically by default + strips debug
+# symbols in release builds.
+# The latest version can be found at
+# https://gist.github.com/egor-tensin/cmake-common.
+# Distributed under the MIT License.
+
+# Version: 2017-05-19T13:51:22+00:00
+
+get_directory_property(parent_directory PARENT_DIRECTORY)
+set(is_root_project $<NOT:parent_directory>)
+
+set(USE_STATIC_RUNTIME "${is_root_project}" CACHE BOOL "Link the runtime statically")
+set(STRIP_SYMBOL_TABLE "${is_root_project}" CACHE BOOL "Strip symbol tables")
+
+if(is_root_project)
+    if(MSVC)
+        add_compile_options(/MP /W4)
+    elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+        add_compile_options(-Wall -Wextra)
+    endif()
+endif()
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+function(use_static_runtime_msvc target)
+    get_target_property(target_type "${target}" TYPE)
+    if(target_type STREQUAL INTERFACE_LIBRARY)
+    else()
+        target_compile_options("${target}" PRIVATE
+            $<$<CONFIG:Debug>:/MTd>
+            $<$<NOT:$<CONFIG:Debug>>:/MT>)
+    endif()
+endfunction()
+
+function(use_static_runtime_gcc target)
+    get_target_property(target_type "${target}" TYPE)
+    if(target_type STREQUAL EXECUTABLE)
+        target_link_libraries("${target}" PRIVATE -static)
+    endif()
+endfunction()
+
+function(use_static_runtime target)
+    if(MSVC)
+        use_static_runtime_msvc("${target}")
+    elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+        use_static_runtime_gcc("${target}")
+    else()
+        message(WARNING "Unrecognized toolset")
+    endif()
+endfunction()
+
+function(strip_symbol_table_gcc target)
+    get_target_property(target_type "${target}" TYPE)
+    set(release_build $<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>>)
+    if(target_type STREQUAL INTERFACE_LIBRARY)
+    else()
+        target_link_libraries("${target}" PRIVATE $<${release_build}:-s>)
+    endif()
+endfunction()
+
+function(strip_symbol_table target)
+    if(MSVC)
+    elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+        strip_symbol_table_gcc("${target}")
+    else()
+        message(WARNING "Unrecognized toolset")
+    endif()
+endfunction()
+
+function(apply_common_settings target)
+    if(TARGET "${target}")
+        get_target_property(target_imported "${target}" IMPORTED)
+        if(target_imported STREQUAL NOTFOUND OR NOT target_imported)
+            if(STRIP_SYMBOL_TABLE)
+                strip_symbol_table("${target}")
+            endif()
+            if(USE_STATIC_RUNTIME)
+                use_static_runtime("${target}")
+            endif()
+        endif()
+    endif()
+endfunction()
+
+macro(add_executable target)
+    _add_executable(${ARGV})
+    apply_common_settings("${target}")
+endmacro()
+
+macro(add_library target)
+    _add_library(${ARGV})
+    apply_common_settings("${target}")
+endmacro()
diff --git a/std_call_once_bug/CMakeLists.txt b/std_call_once_bug/CMakeLists.txt
new file mode 100644
index 0000000..31d45de
--- /dev/null
+++ b/std_call_once_bug/CMakeLists.txt
@@ -0,0 +1,5 @@
+project(std_call_once_bug CXX)
+
+include(../common.cmake)
+
+add_executable(sample sample.cpp)
diff --git a/std_call_once_bug/README.md b/std_call_once_bug/README.md
new file mode 100644
index 0000000..c42f191
--- /dev/null
+++ b/std_call_once_bug/README.md
@@ -0,0 +1,27 @@
+std::call_once bug in Visual C++ 2012/2013
+==========================================
+
+Code samples from the post "std::call_once bug in Visual C++ 2012/2013".
+
+Building
+--------
+
+Create the build files using CMake and build using your native build tools
+(Visual Studio/make/etc.).
+
+In the example below, the project directory is
+"C:\workspace\personal\cpp-notes" and Visual Studio 2013 is used, targeting
+x86.
+
+    > cmake -G "Visual Studio 12 2013" C:\workspace\personal\cpp-notes\std_call_once_bug
+    ...
+
+    > cmake --build . --config release
+    ...
+
+See also
+--------
+
+* [License]
+
+[License]: ../README.md#license
diff --git a/std_call_once_bug/sample.cpp b/std_call_once_bug/sample.cpp
new file mode 100644
index 0000000..22a63c6
--- /dev/null
+++ b/std_call_once_bug/sample.cpp
@@ -0,0 +1,131 @@
+// Copyright (c) 2016 Egor Tensin <Egor.Tensin@gmail.com>
+// This file is part of the "C++ notes" project.
+// For details, see https://github.com/egor-tensin/cpp-notes.
+// Distributed under the MIT License.
+
+#include <ctime>
+
+#include <chrono>
+#include <iostream>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <thread>
+
+namespace
+{
+    template <typename Derived>
+    class Singleton
+    {
+    public:
+        static Derived& get_instance()
+        {
+            std::call_once(initialized_flag, &initialize_instance);
+            return Derived::get_instance_unsafe();
+        }
+
+    protected:
+        Singleton() = default;
+        ~Singleton() = default;
+
+        static Derived& get_instance_unsafe()
+        {
+            static Derived instance;
+            return instance;
+        }
+
+    private:
+        static void initialize_instance()
+        {
+            Derived::get_instance_unsafe();
+        }
+
+        static std::once_flag initialized_flag;
+
+        Singleton(const Singleton&) = delete;
+        Singleton& operator=(const Singleton&) = delete;
+    };
+
+    template <typename Derived>
+    std::once_flag Singleton<Derived>::initialized_flag;
+
+    class Logger : public Singleton<Logger>
+    {
+    public:
+        Logger& operator<<(const char*)
+        {
+            return *this;
+        }
+
+    private:
+        Logger()
+        {
+            std::this_thread::sleep_for(std::chrono::seconds{3});
+        }
+
+        ~Logger() = default;
+
+        friend class Singleton<Logger>;
+    };
+
+    class Duke : public Singleton<Duke>
+    {
+    private:
+        Duke()
+        {
+            Logger::get_instance() << "started Duke's initialization";
+            std::this_thread::sleep_for(std::chrono::seconds{10});
+            Logger::get_instance() << "finishing Duke's initialization";
+        }
+
+        ~Duke() = default;
+
+        friend class Singleton<Duke>;
+    };
+
+    std::mutex timestamp_mtx;
+
+    std::string get_timestamp()
+    {
+        std::lock_guard<std::mutex> lck{timestamp_mtx};
+        const auto tt = std::time(NULL);
+        return std::ctime(&tt);
+    }
+
+    void entered(const char* f)
+    {
+        std::ostringstream oss;
+        oss << "Entered " << f << " at " << get_timestamp();
+        std::cout << oss.str();
+    }
+
+    void exiting(const char* f)
+    {
+        std::ostringstream oss;
+        oss << "Exiting " << f << " at " << get_timestamp();
+        std::cout << oss.str();
+    }
+
+    void get_logger()
+    {
+        entered(__FUNCTION__);
+        Logger::get_instance();
+        exiting(__FUNCTION__);
+    }
+
+    void get_duke()
+    {
+        entered(__FUNCTION__);
+        Duke::get_instance();
+        exiting(__FUNCTION__);
+    }
+}
+
+int main()
+{
+    std::thread t1{&get_duke};
+    std::thread t2{&get_logger};
+    t1.join();
+    t2.join();
+    return 0;
+}