Udpated example and spdlog.h

example/example.cpp

@@ -11,19 +11,13 @@
 #define SPDLOG_DEBUG_ON
 
 
-
+#include "spdlog/sinks/stdout_color_sinks.h"
-
+#include "spdlog/sinks/file_sinks.h"
-#include "spdlog/color_logger.h"
-//#include "spdlog/stdout_logger.h"
-//#include "spdlog/async.h"
-#include "spdlog/spdlog.h"
 
 #include <iostream>
 #include <memory>
 
 void async_example();
-void syslog_example();
-void android_example();
 void user_defined_example();
 void err_handler_example();
 
@@ -31,23 +25,8 @@ namespace spd = spdlog;
 int main(int, char *[])
 {
 
-
 	try
 	{			
-		
-		// Console logger with color		
-		//spd::init_thread_pool(8192, 3);
-
-		auto console1 = spdlog::stdout_color_mt("console111");
-		auto console2 = spdlog::stdout_color_mt<>("console2");
-		//auto console3 = spdlog::stdout_color_mt<spdlog::create_async>("console3");
-		for (int i = 0; i < 10000; i++)
-		{
-			console1->info(111111);
-			console2->warn(222222);
-		}
-		spdlog::drop_all();
-		return 0;
 		auto console = spdlog::stdout_color_st("console");
 		console->info("Welcome to spdlog!");
 
@@ -101,11 +80,6 @@ int main(int, char *[])
 		// Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
 		async_example();
 		
-		// syslog example. linux/osx only
-		syslog_example();
-
-		// android example. compile with NDK
-		android_example();
 
 		// Log user-defined types example
 		user_defined_example();
@@ -130,38 +104,40 @@ int main(int, char *[])
 #include "spdlog/async.h"
 void async_example()
 {
-
 	auto async_file = spd::basic_logger_mt<spdlog::create_async>("async_file_logger", "logs/async_log.txt");
 	for (int i = 0; i < 100; ++i)
 	{
 		async_file->info("Async message #{}", i);
 	}	
 
-	// optional change thread pool settings *before* creating the logger:
+	// you can also modify thread pool settings *before* creating the logger:
-	// spdlog::init_thread_pool(8192, 1);
+	// spdlog::init_thread_pool(32768, 4); // queue with 32k of pre allocated items and 4 backing threads.
-	// if not called a defaults are: 8192 queue size and 1 worker thread.
+	// if not called a defaults are: preallocated 8192 queue items and 1 worker thread.
 }
 
 // syslog example (linux/osx/freebsd)
+#ifndef _WIN32
+#incude "spdlog/sinks/syslog_sink.h"
 void syslog_example()
 {
-#ifdef SPDLOG_ENABLE_SYSLOG
 	std::string ident = "spdlog-example";
 	auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
 	syslog_logger->warn("This is warning that will end up in syslog.");
-#endif
 }
+#endif
 
 // Android example
+#if defined(__ANDROID__)
+#incude "spdlog/sinks/android_sink.h"
 void android_example()
 {
-#if defined(__ANDROID__)
 	std::string tag = "spdlog-android";
 	auto android_logger = spd::android_logger("android", tag);
 	android_logger->critical("Use \"adb shell logcat\" to view this message.");
-#endif
 }
 
+#endif
+
 // user defined types logging by implementing operator<<
 struct my_type
 {

example/example.sln

@@ -58,7 +58,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sinks", "sinks", "{27D16BB9
 		..\include\spdlog\sinks\android_sink.h = ..\include\spdlog\sinks\android_sink.h
 		..\include\spdlog\sinks\ansicolor_sink.h = ..\include\spdlog\sinks\ansicolor_sink.h
 		..\include\spdlog\sinks\base_sink.h = ..\include\spdlog\sinks\base_sink.h
-		..\include\spdlog\color_logger.h = ..\include\spdlog\color_logger.h
+		..\include\spdlog\sinks\stdout_color_sinks.h = ..\include\spdlog\sinks\stdout_color_sinks.h
 		..\include\spdlog\sinks\dist_sink.h = ..\include\spdlog\sinks\dist_sink.h
 		..\include\spdlog\sinks\file_sinks.h = ..\include\spdlog\sinks\file_sinks.h
 		..\include\spdlog\sinks\msvc_sink.h = ..\include\spdlog\sinks\msvc_sink.h

include/spdlog/sinks/android_sink.h

@@ -86,6 +86,17 @@ private:
 		};
 
 	} // namespace sinks
+
+
+	  // Create and register android syslog logger
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> android_logger(const std::string &logger_name, const std::string &tag = "spdlog")
+	{
+		return return Factory::template create<sinks::android_sink>(logger_name, tag);
+	}
+
+
 } // namespace spdlog
 
 #endif

include/spdlog/sinks/ansicolor_sink.h

@@ -141,4 +141,5 @@ using ansicolor_stderr_sink_mt = ansicolor_sink<details::console_stderr_trait, d
 		using ansicolor_stderr_sink_st = ansicolor_sink<details::console_stderr_trait, details::console_null_mutex_trait>;
 
 	} // namespace sinks
+
 } // namespace spdlog

include/spdlog/sinks/color_sinks.h

@@ -1,12 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#ifdef _WIN32
-#include "wincolor_sink.h"
-#else
-#include "ansicolor_sink.h"
-#endif
-

include/spdlog/sinks/file_sinks.h

@@ -252,4 +252,53 @@ using daily_file_sink_mt = daily_file_sink<std::mutex>;
 		using daily_file_sink_st = daily_file_sink<details::null_mutex>;
 
 	} // namespace sinks
+
+	//
+	// factory functions to create and register file loggers
+	//
+	
+	// Basic logger simply writes to given file without any limitations or rotations.	
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false)
+	{
+		return Factory::template create<sinks::simple_file_sink_mt>(logger_name, filename, truncate);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false)
+	{
+		return Factory::template create<sinks::simple_file_sink_st>(logger_name, filename, truncate);
+	}
+
+	//
+	// Create and register multi/single threaded rotating file logger
+	//
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> rotating_logger_mt(
+		const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
+	{
+		return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> rotating_logger_st(
+		const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
+	{
+		return Factory::template create<sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, max_files);
+	}
+
+	//
+	// Create file logger which creates new file on the given time (default in midnight):
+	//
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0)
+	{
+		return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0)
+	{
+		return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute);
+	}
 } // namespace spdlog

include/spdlog/sinks/stdout_color_sinks.h

@@ -0,0 +1,55 @@
+//
+// Copyright(c) 2018 spdlog
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include "../spdlog.h"
+#ifdef _WIN32
+#include "wincolor_sink.h"
+#else
+#include "ansicolor_sink.h"
+#endif
+
+namespace {	
+	using namespace spdlog::sinks;
+#ifdef _WIN32
+	using stdout_color_sink_mt = wincolor_stdout_sink_mt;
+	using stdout_color_sink_st = wincolor_stdout_sink_st;
+	using stderr_color_sink_mt = wincolor_stderr_sink_mt;
+	using stderr_color_sink_st = wincolor_stderr_sink_st;
+#else
+	using stdout_color_sink_mt = ansicolor_stdout_sink_mt;
+	using stdout_color_sink_st = ansicolor_stdout_sink_st;
+	using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
+	using stderr_color_sink_st = ansicolor_stderr_sink_st;
+
+#endif
+}
+
+namespace spdlog 
+{	
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name)
+	{
+		return Factory::template create<stdout_color_sink_mt>(logger_name);
+	}
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stdout_color_st(const std::string &logger_name)
+	{
+		return Factory::template create<stdout_color_sink_st>(logger_name);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name)
+	{
+		return Factory::template create<stderr_color_sink_mt>(logger_name);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stderr_color_st(const std::string &logger_name)
+	{
+		return Factory::template createstderr_color_sink_mt>(logger_name);
+	}
+}

include/spdlog/sinks/stdout_sinks.h

@@ -51,4 +51,29 @@ using stderr_sink_mt = stdout_sink<details::console_stderr_trait, details::conso
 		using stderr_sink_st = stdout_sink<details::console_stderr_trait, details::console_null_mutex_trait>;
 
 	} // namespace sinks
+
+	// factory methods
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name)
+	{
+		return Factory::template create<stdout_color_sink_mt>(logger_name);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name)
+	{
+		return Factory::template create<stdout_color_sink_mt>(logger_name);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name)
+	{
+		return Factory::template create<stderr_color_sink_mt>(logger_name);
+	}
+
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name)
+	{
+		return Factory::template create<stderr_logger_sink_mt>(logger_name);
+	}
 } // namespace spdlog

include/spdlog/sinks/syslog_sink.h

@@ -71,6 +71,14 @@ private:
 			}
 		};
 	} // namespace sinks
+
+	  // Create and register a syslog logger
+	template<typename Factory = default_factory>
+	inline std::shared_ptr<logger> syslog_logger(
+		const std::string &logger_name, const std::string &ident = "", int syslog_option = 0, int syslog_facilty = (1 << 3))
+	{
+		return return Factory::template create<sinks::syslog_sink>(logger_name, syslog_ident, syslog_option, syslog_facility);
+	}
 } // namespace spdlog
 
 #endif

include/spdlog/spdlog.h

@@ -8,17 +8,9 @@
 #pragma once
 
 #include "details/registry.h"
-#include "sinks/file_sinks.h"
-#include "sinks/stdout_sinks.h"
-
 #include "common.h"
 #include "logger.h"
 
-
-#ifdef __ANDROID__
-#include "sinks/android_sink.h"
-#endif
-
 #include <chrono>
 #include <functional>
 #include <memory>
@@ -27,7 +19,7 @@
 namespace spdlog {
 
 // Default logger factory-  creates synchronous loggers
-struct create_synchronous
+struct default_factory
 {
     template<typename Sink, typename... SinkArgs>
 
@@ -40,41 +32,6 @@ struct create_synchronous
     }
 };
 
-using default_factory = create_synchronous;
-
-
-
-//
-// color console loggers
-//
-// you must include "spdlog/sinks/color_sinks.h" before creating color loggers
-//
-// #include "spdlog/color_console.h"
-//
-// using namespace spdlog::sinks
-// auto logger = spdlog::console<stdout_color_mt>("logger_name1");
-// auto logger = spdlog::console<stdout_color_st>("logger_name2");
-// auto looger = spdlog::console<stderr_color_mt>("logger_name3");
-//
-//
-// create asynchrounous color logger 
-// you must include "spdlog/asynch.h" before creating async loggers
-//
-// #include "spdlog/asynch."
-// #include "spdlog/sinks/color_sinks.h"
-// auto async_console = spdlog::console<stderr_color_st, spdlog::create_async>("some_name");
-// or
-// auto async_console = spdlog::create_async_logger<stdout_color_mt>("Console2");
-
-
-
-
-//template<typename console_type, typename Factory = create_synchronous>
-//inline std::shared_ptr<logger> console(const std::string &logger_name)
-//{
-//	return Factory::template create<console_type>(logger_name);
-//}
-
 
 // Create and register a logger with a templated sink type
 // The logger's level, formatter and flush level will be set according the global settings.
@@ -159,73 +116,6 @@ inline void drop_all()
     details::registry::instance().drop_all();
 }
 
-//
-// Create and register multi/single threaded basic file logger.
-// Basic logger simply writes to given file without any limitations or rotations.
-//
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false)
-{
-    return Factory::template create<sinks::simple_file_sink_mt>(logger_name, filename, truncate);
-}
-
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false)
-{
-    return Factory::template create<sinks::simple_file_sink_st>(logger_name, filename, truncate);
-}
-
-//
-// Create and register multi/single threaded rotating file logger
-//
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> rotating_logger_mt(
-    const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
-{
-    return Factory::template create<sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files);
-}
-
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> rotating_logger_st(
-    const std::string &logger_name, const filename_t &filename, size_t max_file_size, size_t max_files)
-{
-    return Factory::template create<sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, max_files);
-}
-
-//
-// Create file logger which creates new file on the given time (default in midnight):
-//
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0)
-{
-    return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute);
-}
-
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, const filename_t &filename, int hour = 0, int minute = 0)
-{
-    return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute);
-}
-
-
-#ifdef SPDLOG_ENABLE_SYSLOG
-// Create and register a syslog logger
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> syslog_logger(
-    const std::string &logger_name, const std::string &ident = "", int syslog_option = 0, int syslog_facilty = (1 << 3))
-{
-    return return Factory::template create<sinks::syslog_sink>(logger_name, syslog_ident, syslog_option, syslog_facility);
-}
-#endif
-
-#if defined(__ANDROID__)
-// Create and register android syslog logger
-template<typename Factory = default_factory>
-inline std::shared_ptr<logger> android_logger(const std::string &logger_name, const std::string &tag = "spdlog")
-{
-    return return Factory::template create<sinks::android_sink>(logger_name, tag);
-}
-#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 //

include/spdlog/tweakme.h

@@ -102,12 +102,6 @@
 // #define SPDLOG_FMT_PRINTF
 ///////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable syslog (disabled by default)
-//
-// #define SPDLOG_ENABLE_SYSLOG
-///////////////////////////////////////////////////////////////////////////////
-
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to enable wchar_t support (convert to utf8)
 //