WIP

CMakeLists.txt

@@ -2,11 +2,11 @@
 
 cmake_minimum_required(VERSION 3.2)
 
-if(${CMAKE_VERSION} VERSION_LESS 3.11)
+if (${CMAKE_VERSION} VERSION_LESS 3.11)
     cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
+else ()
     cmake_policy(VERSION 3.14)
-endif()
+endif ()
 
 enable_language(C)
 
@@ -26,35 +26,35 @@ include(GNUInstallDirs)
 # ---------------------------------------------------------------------------------------
 # Set default build to release
 # ---------------------------------------------------------------------------------------
-if(NOT CMAKE_BUILD_TYPE)
+if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Compiler config
 # ---------------------------------------------------------------------------------------
-if(NOT CMAKE_CXX_STANDARD)
+if (NOT CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 11)
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif()
+endif ()
 
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN")
+if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN")
     set(CMAKE_CXX_EXTENSIONS ON)
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
 # ---------------------------------------------------------------------------------------
 # Check if spdlog is being used directly or via add_subdirectory, but allow overriding
-if(NOT DEFINED SPDLOG_MASTER_PROJECT)
+if (NOT DEFINED SPDLOG_MASTER_PROJECT)
-    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
         set(SPDLOG_MASTER_PROJECT ON)
-    else()
+    else ()
         set(SPDLOG_MASTER_PROJECT OFF)
-    endif()
+    endif ()
-endif()
+endif ()
 
 option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)
 
@@ -66,11 +66,9 @@ option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled heade
 
 # example options
 option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
-option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
 
 # testing options
 option(SPDLOG_BUILD_TESTS "Build tests" OFF)
-option(SPDLOG_BUILD_TESTS_HO "Build tests using the header only version" OFF)
 
 # bench options
 option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF)
@@ -87,19 +85,19 @@ option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
 option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
 option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
 
-if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
+if (SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
     message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif()
+endif ()
 
 # misc tweakme options
-if(WIN32)
+if (WIN32)
     option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
     option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
-endif()
+endif ()
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     option(SPDLOG_CLOCK_COARSE
             "Use the much faster (but much less accurate) CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
-endif()
+endif ()
 
 option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
 option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
@@ -110,44 +108,69 @@ option(
         OFF)
 
 # clang-tidy
-if(${CMAKE_VERSION} VERSION_GREATER "3.5")
+if (${CMAKE_VERSION} VERSION_GREATER "3.5")
     option(SPDLOG_TIDY "run clang-tidy" OFF)
-endif()
+endif ()
 
-if(SPDLOG_TIDY)
+if (SPDLOG_TIDY)
     set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
     set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
     message(STATUS "Enabled clang-tidy")
-endif()
+endif ()
 
 find_package(Threads REQUIRED)
 message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
 # ---------------------------------------------------------------------------------------
 # Static/Shared library (shared not supported in windows yet)
 # ---------------------------------------------------------------------------------------
-set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)
+set(SPDLOG_SRCS
-
+        src/ansicolor_sink.cpp
-if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+        src/async.cpp
+        src/async_logger.cpp
+        src/backtracer.cpp
+        src/base_sink.cpp
+        src/basic_file_sink.cpp
+        src/common.cpp
+        src/file_helper.cpp
+        src/fmt.cpp
+        src/helpers.cpp
+        src/logger.cpp
+        src/log_msg_buffer.cpp
+        src/log_msg.cpp
+        src/os.cpp
+        src/pattern_formatter.cpp
+        src/periodic_worker.cpp
+        src/registry.cpp
+        src/rotating_file_sink.cpp
+        src/sink.cpp
+        src/spdlog.cpp
+        src/spdlog-inl.cpp
+        src/stdout_color_sinks.cpp
+        src/stdout_sinks.cpp
+        src/thread_pool.cpp
+        )
+
+if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
     list(APPEND SPDLOG_SRCS src/fmt.cpp)
-endif()
+endif ()
 
-if(WIN32 AND SPDLOG_BUILD_SHARED)
+if (WIN32 AND SPDLOG_BUILD_SHARED)
     list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-endif()
+endif ()
 
-if(SPDLOG_BUILD_SHARED)
+if (SPDLOG_BUILD_SHARED)
     add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
     target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if(WIN32)
+    if (WIN32)
         target_compile_options(spdlog PUBLIC /wd4251 /wd4275)
         configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
-    endif()
+    endif ()
-    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
         target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
-    endif()
+    endif ()
-else()
+else ()
     add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-endif()
+endif ()
 
 add_library(spdlog::spdlog ALIAS spdlog)
 
@@ -160,118 +183,109 @@ spdlog_enable_warnings(spdlog)
 set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR})
 set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
 
-if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
+if (COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
     target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
-endif()
+endif ()
 
-# ---------------------------------------------------------------------------------------
-# Header only version
-# ---------------------------------------------------------------------------------------
-add_library(spdlog_header_only INTERFACE)
-add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
-
-target_include_directories(spdlog_header_only INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-                                                        "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
 
 # ---------------------------------------------------------------------------------------
 # Use fmt package if using external fmt
 # ---------------------------------------------------------------------------------------
-if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
+if (SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    if(NOT TARGET fmt::fmt)
+    if (NOT TARGET fmt::fmt)
         find_package(fmt 5.3.0 REQUIRED)
-    endif()
+    endif ()
     target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)
 
     # use external fmt-header-nly
-    if(SPDLOG_FMT_EXTERNAL_HO)
+    if (SPDLOG_FMT_EXTERNAL_HO)
         target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
         target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
-    else() # use external compile fmt
+    else () # use external compile fmt
         target_link_libraries(spdlog PUBLIC fmt::fmt)
         target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
-    endif()
+    endif ()
 
     set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Misc definitions according to tweak options
 # ---------------------------------------------------------------------------------------
-if(SPDLOG_WCHAR_SUPPORT)
+if (SPDLOG_WCHAR_SUPPORT)
     target_compile_definitions(spdlog PUBLIC SPDLOG_WCHAR_TO_UTF8_SUPPORT)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-endif()
+endif ()
 
-if(SPDLOG_WCHAR_FILENAMES)
+if (SPDLOG_WCHAR_FILENAMES)
     target_compile_definitions(spdlog PUBLIC SPDLOG_WCHAR_FILENAMES)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_WCHAR_FILENAMES)
-endif()
+endif ()
 
-if(SPDLOG_NO_EXCEPTIONS)
+if (SPDLOG_NO_EXCEPTIONS)
     target_compile_definitions(spdlog PUBLIC SPDLOG_NO_EXCEPTIONS)
 
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_EXCEPTIONS)
 
-    if(NOT MSVC)
+    if (NOT MSVC)
         target_compile_options(spdlog PRIVATE -fno-exceptions)
-    endif()
+    endif ()
-endif()
+endif ()
 
-if(SPDLOG_CLOCK_COARSE)
+if (SPDLOG_CLOCK_COARSE)
     target_compile_definitions(spdlog PRIVATE SPDLOG_CLOCK_COARSE)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_CLOCK_COARSE)
-endif()
+endif ()
 
-if(SPDLOG_PREVENT_CHILD_FD)
+if (SPDLOG_PREVENT_CHILD_FD)
     target_compile_definitions(spdlog PRIVATE SPDLOG_PREVENT_CHILD_FD)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_PREVENT_CHILD_FD)
-endif()
+endif ()
 
-if(SPDLOG_NO_THREAD_ID)
+if (SPDLOG_NO_THREAD_ID)
     target_compile_definitions(spdlog PRIVATE SPDLOG_NO_THREAD_ID)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_THREAD_ID)
-endif()
+endif ()
 
-if(SPDLOG_NO_TLS)
+if (SPDLOG_NO_TLS)
     target_compile_definitions(spdlog PRIVATE SPDLOG_NO_TLS)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_TLS)
-endif()
+endif ()
 
-if(SPDLOG_NO_ATOMIC_LEVELS)
+if (SPDLOG_NO_ATOMIC_LEVELS)
     target_compile_definitions(spdlog PUBLIC SPDLOG_NO_ATOMIC_LEVELS)
     target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_NO_ATOMIC_LEVELS)
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Build binaries
 # ---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
+if (SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
     message(STATUS "Generating example(s)")
     add_subdirectory(example)
     spdlog_enable_warnings(example)
-    if(SPDLOG_BUILD_EXAMPLE_HO)
+    if (SPDLOG_BUILD_EXAMPLE_HO)
         spdlog_enable_warnings(example_header_only)
-    endif()
+    endif ()
-endif()
+endif ()
 
-if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
+if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
     message(STATUS "Generating tests")
     enable_testing()
     add_subdirectory(tests)
-endif()
+endif ()
 
-if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
+if (SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
     message(STATUS "Generating benchmarks")
     add_subdirectory(bench)
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Install
 # ---------------------------------------------------------------------------------------
-if(SPDLOG_INSTALL)
+if (SPDLOG_INSTALL)
     message(STATUS "Generating install")
     set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
     set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
@@ -286,16 +300,16 @@ if(SPDLOG_INSTALL)
     # ---------------------------------------------------------------------------------------
     install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
     install(
-        TARGETS spdlog spdlog_header_only
+            TARGETS spdlog
             EXPORT spdlog
             LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
             ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
             RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
-    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
+    if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
         install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
                 DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
-    endif()
+    endif ()
 
     # ---------------------------------------------------------------------------------------
     # Install pkg-config file
@@ -321,4 +335,4 @@ if(SPDLOG_INSTALL)
     # Support creation of installable packages
     # ---------------------------------------------------------------------------------------
     include(cmake/spdlogCPack.cmake)
-endif()
+endif ()

example/CMakeLists.txt

@@ -3,21 +3,13 @@
 cmake_minimum_required(VERSION 3.2)
 project(spdlog_examples CXX)
 
-if(NOT TARGET spdlog)
+if (NOT TARGET spdlog)
     # Stand-alone build
     find_package(spdlog REQUIRED)
-endif()
+endif ()
 
 # ---------------------------------------------------------------------------------------
 # Example of using pre-compiled library
 # ---------------------------------------------------------------------------------------
 add_executable(example example.cpp)
 target_link_libraries(example PRIVATE spdlog::spdlog)
-
-# ---------------------------------------------------------------------------------------
-# Example of using header-only library
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE_HO)
-    add_executable(example_header_only example.cpp)
-    target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)
-endif()

include/spdlog/async_logger-inl.h

@@ -1,92 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/async_logger.h>
-#endif
-
-#include <spdlog/sinks/sink.h>
-#include <spdlog/details/thread_pool.h>
-
-#include <memory>
-#include <string>
-
-SPDLOG_INLINE spdlog::async_logger::async_logger(
-    std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
-{}
-
-SPDLOG_INLINE spdlog::async_logger::async_logger(
-    std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
-{}
-
-// send the log message to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
-{
-    if (auto pool_ptr = thread_pool_.lock())
-    {
-        pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
-    }
-    else
-    {
-        throw_spdlog_ex("async log: thread pool doesn't exist anymore");
-    }
-}
-
-// send flush request to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::flush_()
-{
-    if (auto pool_ptr = thread_pool_.lock())
-    {
-        pool_ptr->post_flush(shared_from_this(), overflow_policy_);
-    }
-    else
-    {
-        throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
-    }
-}
-
-//
-// backend functions - called from the thread pool to do the actual job
-//
-SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
-{
-    for (auto &sink : sinks_)
-    {
-        if (sink->should_log(msg.level))
-        {
-            SPDLOG_TRY
-            {
-                sink->log(msg);
-            }
-            SPDLOG_LOGGER_CATCH()
-        }
-    }
-
-    if (should_flush_(msg))
-    {
-        backend_flush_();
-    }
-}
-
-SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
-{
-    for (auto &sink : sinks_)
-    {
-        SPDLOG_TRY
-        {
-            sink->flush();
-        }
-        SPDLOG_LOGGER_CATCH()
-    }
-}
-
-SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
-{
-    auto cloned = std::make_shared<spdlog::async_logger>(*this);
-    cloned->name_ = std::move(new_name);
-    return cloned;
-}

include/spdlog/common.h

@@ -15,8 +15,6 @@
 #include <type_traits>
 #include <functional>
 
-#ifdef SPDLOG_COMPILED_LIB
-#undef SPDLOG_HEADER_ONLY
 #if defined(_WIN32) && defined(SPDLOG_SHARED_LIB)
 #ifdef spdlog_EXPORTS
 #define SPDLOG_API __declspec(dllexport)
@@ -25,13 +23,8 @@
 #endif
 #else // !defined(_WIN32) || !defined(SPDLOG_SHARED_LIB)
 #define SPDLOG_API
-#endif
 #define SPDLOG_INLINE
-#else // !defined(SPDLOG_COMPILED_LIB)
+#endif
-#define SPDLOG_API
-#define SPDLOG_HEADER_ONLY
-#define SPDLOG_INLINE inline
-#endif // #ifdef SPDLOG_COMPILED_LIB
 
 #include <spdlog/fmt/fmt.h>
 
@@ -234,7 +227,3 @@ std::unique_ptr<T> make_unique(Args &&... args)
 #endif
 } // namespace details
 } // namespace spdlog
-
-#ifdef SPDLOG_HEADER_ONLY
-#include "common-inl.h"
-#endif

include/spdlog/details/periodic_worker.h

@@ -14,6 +14,7 @@
 #include <functional>
 #include <mutex>
 #include <thread>
+#include <spdlog/common.h>
 namespace spdlog {
 namespace details {
 

include/spdlog/details/thread_pool.h

@@ -6,6 +6,7 @@
 #include <spdlog/details/log_msg_buffer.h>
 #include <spdlog/details/mpmc_blocking_q.h>
 #include <spdlog/details/os.h>
+#include <spdlog/async_logger.h>
 
 #include <chrono>
 #include <memory>

include/spdlog/sinks/ansicolor_sink-inl.h

@@ -1,143 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/ansicolor_sink.h>
-#endif
-
-#include <spdlog/pattern_formatter.h>
-#include <spdlog/details/os.h>
-
-namespace spdlog {
-namespace sinks {
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
-    : target_file_(target_file)
-    , mutex_(ConsoleMutex::mutex())
-    , formatter_(details::make_unique<spdlog::pattern_formatter>())
-
-{
-    set_color_mode(mode);
-    colors_[level::trace] = to_string_(white);
-    colors_[level::debug] = to_string_(cyan);
-    colors_[level::info] = to_string_(green);
-    colors_[level::warn] = to_string_(yellow_bold);
-    colors_[level::err] = to_string_(red_bold);
-    colors_[level::critical] = to_string_(bold_on_red);
-    colors_[level::off] = to_string_(reset);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, string_view_t color)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    colors_[color_level] = to_string_(color);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
-{
-    // Wrap the originally formatted message in color codes.
-    // If color is not supported in the terminal, log as is instead.
-    std::lock_guard<mutex_t> lock(mutex_);
-    msg.color_range_start = 0;
-    msg.color_range_end = 0;
-    memory_buf_t formatted;
-    formatter_->format(msg, formatted);
-    if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
-    {
-        // before color range
-        print_range_(formatted, 0, msg.color_range_start);
-        // in color range
-        print_ccode_(colors_[msg.level]);
-        print_range_(formatted, msg.color_range_start, msg.color_range_end);
-        print_ccode_(reset);
-        // after color range
-        print_range_(formatted, msg.color_range_end, formatted.size());
-    }
-    else // no color
-    {
-        print_range_(formatted, 0, formatted.size());
-    }
-    fflush(target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush()
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    fflush(target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::move(sink_formatter);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color()
-{
-    return should_do_colors_;
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
-{
-    switch (mode)
-    {
-    case color_mode::always:
-        should_do_colors_ = true;
-        return;
-    case color_mode::automatic:
-        should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
-        return;
-    case color_mode::never:
-        should_do_colors_ = false;
-        return;
-    }
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code)
-{
-    fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, size_t start, size_t end)
-{
-    fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
-{
-    return std::string(sv.data(), sv.size());
-}
-
-// ansicolor_stdout_sink
-template<typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stdout, mode)
-{}
-
-// ansicolor_stderr_sink
-template<typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stderr, mode)
-{}
-
-} // namespace sinks
-} // namespace spdlog

include/spdlog/sinks/stdout_color_sinks-inl.h

@@ -1,38 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/stdout_color_sinks.h>
-#endif
-
-#include <spdlog/logger.h>
-#include <spdlog/common.h>
-
-namespace spdlog {
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode)
-{
-    return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
-}
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode)
-{
-    return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
-}
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode)
-{
-    return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
-}
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
-{
-    return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
-}
-} // namespace spdlog

include/spdlog/sinks/stdout_color_sinks.h

@@ -39,7 +39,3 @@ template<typename Factory = spdlog::synchronous_factory>
 std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode = color_mode::automatic);
 
 } // namespace spdlog
-
-#ifdef SPDLOG_HEADER_ONLY
-#include "stdout_color_sinks-inl.h"
-#endif

include/spdlog/sinks/stdout_sinks-inl.h

@@ -1,94 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/stdout_sinks.h>
-#endif
-
-#include <spdlog/details/console_globals.h>
-#include <spdlog/pattern_formatter.h>
-#include <memory>
-
-namespace spdlog {
-
-namespace sinks {
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
-    : mutex_(ConsoleMutex::mutex())
-    , file_(file)
-    , formatter_(details::make_unique<spdlog::pattern_formatter>())
-{}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    memory_buf_t formatted;
-    formatter_->format(msg, formatted);
-    fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
-    fflush(file_); // flush every line to terminal
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush()
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    fflush(file_);
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
-}
-
-template<typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
-{
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::move(sink_formatter);
-}
-
-// stdout sink
-template<typename ConsoleMutex>
-SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
-    : stdout_sink_base<ConsoleMutex>(stdout)
-{}
-
-// stderr sink
-template<typename ConsoleMutex>
-SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
-    : stdout_sink_base<ConsoleMutex>(stderr)
-{}
-
-} // namespace sinks
-
-// factory methods
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
-{
-    return Factory::template create<sinks::stdout_sink_mt>(logger_name);
-}
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
-{
-    return Factory::template create<sinks::stdout_sink_st>(logger_name);
-}
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
-{
-    return Factory::template create<sinks::stderr_sink_mt>(logger_name);
-}
-
-template<typename Factory>
-SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
-{
-    return Factory::template create<sinks::stderr_sink_st>(logger_name);
-}
-} // namespace spdlog

include/spdlog/sinks/stdout_sinks.h

@@ -74,7 +74,3 @@ template<typename Factory = spdlog::synchronous_factory>
 std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
 
 } // namespace spdlog
-
-#ifdef SPDLOG_HEADER_ONLY
-#include "stdout_sinks-inl.h"
-#endif

src/async.cpp

@@ -1,13 +1,5 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
 #include <spdlog/async.h>
-#include <spdlog/async_logger-inl.h>
-#include <spdlog/details/periodic_worker-inl.h>
-#include <spdlog/details/thread_pool-inl.h>
-
 template class SPDLOG_API spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>;

src/backtracer.cpp

@@ -1,11 +1,8 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/backtracer.h>
-#endif
+
 namespace spdlog {
 namespace details {
 SPDLOG_INLINE backtracer::backtracer(const backtracer &other)

src/base_sink.cpp

@@ -1,15 +1,11 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/sinks/base_sink.h>
-#endif
-
 #include <spdlog/common.h>
 #include <spdlog/pattern_formatter.h>
-
+#include <spdlog/details/null_mutex.h>
+#include <mutex>
 #include <memory>
 
 template<typename Mutex>
@@ -61,3 +57,7 @@ void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_p
 {
     formatter_ = std::move(sink_formatter);
 }
+
+// template instantiations
+template class SPDLOG_API spdlog::sinks::base_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::base_sink<spdlog::details::null_mutex>;

src/basic_file_sink.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/sinks/basic_file_sink.h>
-#endif
-
 #include <spdlog/common.h>
 #include <spdlog/details/os.h>
 
@@ -41,3 +36,7 @@ SPDLOG_INLINE void basic_file_sink<Mutex>::flush_()
 
 } // namespace sinks
 } // namespace spdlog
+
+// template instantiations
+template class SPDLOG_API spdlog::sinks::basic_file_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::basic_file_sink<spdlog::details::null_mutex>;

src/cfg.cpp

@@ -1,8 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
-#include <spdlog/cfg/helpers-inl.h>

src/color_sinks.cpp

@@ -1,51 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
-#include <mutex>
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/async.h>
-//
-// color sinks
-//
-#ifdef _WIN32
-#include <spdlog/sinks/wincolor_sink-inl.h>
-template class SPDLOG_API spdlog::sinks::wincolor_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::wincolor_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_nullmutex>;
-#else
-#include "spdlog/sinks/ansicolor_sink-inl.h"
-template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_nullmutex>;
-#endif
-
-// factory methods for color loggers
-#include "spdlog/sinks/stdout_color_sinks-inl.h"
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::synchronous_factory>(
-    const std::string &logger_name, color_mode mode);
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::synchronous_factory>(
-    const std::string &logger_name, color_mode mode);
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::synchronous_factory>(
-    const std::string &logger_name, color_mode mode);
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::synchronous_factory>(
-    const std::string &logger_name, color_mode mode);
-
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::async_factory>(
-    const std::string &logger_name, color_mode mode);
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory>(
-    const std::string &logger_name, color_mode mode);
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory>(
-    const std::string &logger_name, color_mode mode);
-template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory>(
-    const std::string &logger_name, color_mode mode);

src/common.cpp

@@ -1,11 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/common.h>
-#endif
 
 namespace spdlog {
 namespace level {

src/file_helper.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/file_helper.h>
-#endif
-
 #include <spdlog/details/os.h>
 #include <spdlog/common.h>
 

src/file_sinks.cpp

@@ -1,20 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/details/file_helper-inl.h>
-#include <spdlog/sinks/basic_file_sink-inl.h>
-#include <spdlog/sinks/base_sink-inl.h>
-
-#include <mutex>
-
-template class SPDLOG_API spdlog::sinks::basic_file_sink<std::mutex>;
-template class SPDLOG_API spdlog::sinks::basic_file_sink<spdlog::details::null_mutex>;
-
-#include <spdlog/sinks/rotating_file_sink-inl.h>
-template class SPDLOG_API spdlog::sinks::rotating_file_sink<std::mutex>;
-template class SPDLOG_API spdlog::sinks::rotating_file_sink<spdlog::details::null_mutex>;

src/helpers.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/cfg/helpers.h>
-#endif
-
 #include <spdlog/spdlog.h>
 #include <spdlog/details/os.h>
 #include <spdlog/details/registry.h>

src/log_msg.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/log_msg.h>
-#endif
-
 #include <spdlog/details/os.h>
 
 namespace spdlog {

src/log_msg_buffer.cpp

@@ -1,11 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/log_msg_buffer.h>
-#endif
 
 namespace spdlog {
 namespace details {
@@ -26,7 +22,9 @@ SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
     update_string_views();
 }
 
-SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept : log_msg{other}, buffer{std::move(other.buffer)}
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) noexcept
+    : log_msg{other}
+    , buffer{std::move(other.buffer)}
 {
     update_string_views();
 }

src/logger.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/logger.h>
-#endif
-
 #include <spdlog/sinks/sink.h>
 #include <spdlog/details/backtracer.h>
 #include <spdlog/pattern_formatter.h>
@@ -25,12 +20,13 @@ SPDLOG_INLINE logger::logger(const logger &other)
     , tracer_(other.tracer_)
 {}
 
-SPDLOG_INLINE logger::logger(logger &&other) noexcept : name_(std::move(other.name_)),
+SPDLOG_INLINE logger::logger(logger &&other) noexcept
-                                                               sinks_(std::move(other.sinks_)),
+    : name_(std::move(other.name_))
-                                                               level_(other.level_.load(std::memory_order_relaxed)),
+    , sinks_(std::move(other.sinks_))
-                                                               flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
+    , level_(other.level_.load(std::memory_order_relaxed))
-                                                               custom_err_handler_(std::move(other.custom_err_handler_)),
+    , flush_level_(other.flush_level_.load(std::memory_order_relaxed))
-                                                               tracer_(std::move(other.tracer_))
+    , custom_err_handler_(std::move(other.custom_err_handler_))
+    , tracer_(std::move(other.tracer_))
 
 {}
 

src/os.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/os.h>
-#endif
-
 #include <spdlog/common.h>
 
 #include <algorithm>

src/pattern_formatter.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/pattern_formatter.h>
-#endif
-
 #include <spdlog/details/fmt_helper.h>
 #include <spdlog/details/log_msg.h>
 #include <spdlog/details/os.h>

src/periodic_worker.cpp

@@ -1,11 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/periodic_worker.h>
-#endif
 
 namespace spdlog {
 namespace details {

src/registry.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/registry.h>
-#endif
-
 #include <spdlog/common.h>
 #include <spdlog/details/periodic_worker.h>
 #include <spdlog/logger.h>

src/rotating_file_sink.cpp

@@ -1,14 +1,9 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/sinks/rotating_file_sink.h>
-#endif
-
 #include <spdlog/common.h>
-
+#include <spdlog/details/os.h>
 #include <spdlog/details/file_helper.h>
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/fmt/fmt.h>
@@ -129,3 +124,7 @@ SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src
 
 } // namespace sinks
 } // namespace spdlog
+
+// template instantiations
+template class SPDLOG_API spdlog::sinks::rotating_file_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::rotating_file_sink<spdlog::details::null_mutex>;

src/sink.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/sinks/sink.h>
-#endif
-
 #include <spdlog/common.h>
 
 SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const

src/spdlog-inl.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/spdlog.h>
-#endif
-
 #include <spdlog/common.h>
 #include <spdlog/pattern_formatter.h>
 

src/spdlog.cpp

@@ -1,21 +1,8 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#ifndef SPDLOG_COMPILED_LIB
+#include <spdlog/logger.h>
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+#include <spdlog/sinks/base_sink.h>
-#endif
-
-#include <spdlog/spdlog-inl.h>
-#include <spdlog/common-inl.h>
-#include <spdlog/details/backtracer-inl.h>
-#include <spdlog/details/registry-inl.h>
-#include <spdlog/details/os-inl.h>
-#include <spdlog/pattern_formatter-inl.h>
-#include <spdlog/details/log_msg-inl.h>
-#include <spdlog/details/log_msg_buffer-inl.h>
-#include <spdlog/logger-inl.h>
-#include <spdlog/sinks/sink-inl.h>
-#include <spdlog/sinks/base_sink-inl.h>
 #include <spdlog/details/null_mutex.h>
 
 #include <mutex>

src/stdout_color_sinks.cpp

@@ -0,0 +1,55 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include <spdlog/logger.h>
+#include <spdlog/common.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/async.h>
+
+namespace spdlog {
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
+{
+    return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
+}
+
+// template instantiations
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::synchronous_factory>(
+    const std::string &logger_name, color_mode mode);
+
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory>(
+    const std::string &logger_name, color_mode mode);
+
+} // namespace spdlog

src/stdout_sinks.cpp

@@ -1,15 +1,96 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
-#endif
-
 #include <mutex>
 
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/async.h>
-#include <spdlog/sinks/stdout_sinks-inl.h>
+#include <spdlog/sinks/stdout_sinks.h>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/pattern_formatter.h>
+#include <memory>
+
+namespace spdlog {
+
+namespace sinks {
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
+    : mutex_(ConsoleMutex::mutex())
+    , file_(file)
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
+{}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    memory_buf_t formatted;
+    formatter_->format(msg, formatted);
+    fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
+    fflush(file_); // flush every line to terminal
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush()
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    fflush(file_);
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template<typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
+{
+    std::lock_guard<mutex_t> lock(mutex_);
+    formatter_ = std::move(sink_formatter);
+}
+
+// stdout sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
+    : stdout_sink_base<ConsoleMutex>(stdout)
+{}
+
+// stderr sink
+template<typename ConsoleMutex>
+SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
+    : stdout_sink_base<ConsoleMutex>(stderr)
+{}
+
+} // namespace sinks
+
+// factory methods
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stdout_sink_mt>(logger_name);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stdout_sink_st>(logger_name);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stderr_sink_mt>(logger_name);
+}
+
+template<typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
+{
+    return Factory::template create<sinks::stderr_sink_st>(logger_name);
+}
+} // namespace spdlog
 
 template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::console_mutex>;
 template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::console_nullmutex>;

src/thread_pool.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/details/thread_pool.h>
-#endif
-
 #include <spdlog/common.h>
 #include <cassert>
 

src/wincolor_sink.cpp

@@ -1,12 +1,7 @@
 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
-#pragma once
-
-#ifndef SPDLOG_HEADER_ONLY
 #include <spdlog/sinks/wincolor_sink.h>
-#endif
-
 #include <spdlog/common.h>
 #include <spdlog/pattern_formatter.h>
 

tests/CMakeLists.txt

@@ -64,7 +64,3 @@ if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_ALL)
     spdlog_prepare_test(spdlog-utests spdlog::spdlog)
 endif ()
 
-# The header-only library version tests
-if (SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
-    spdlog_prepare_test(spdlog-utests-ho spdlog::spdlog_header_only)
-endif ()