Namespaces
	cfg

	details

	level

	sinks

Classes
struct	async_factory_impl

class	async_logger

class	custom_flag_formatter

struct	file_event_handlers

class	formatter

struct	is_convertible_to_any_format_string

struct	is_convertible_to_basic_format_string

class	logger

class	pattern_formatter

struct	source_loc

class	spdlog_ex

class	stopwatch

struct	synchronous_factory

Typedefs
using	async_factory = async_factory_impl< async_overflow_policy::block >

using	async_factory_nonblock = async_factory_impl< async_overflow_policy::overrun_oldest >

using	filename_t = std::string

using	log_clock = std::chrono::system_clock

using	sink_ptr = std::shared_ptr< sinks::sink >

using	sinks_init_list = std::initializer_list< sink_ptr >

using	err_handler = std::function< void(const std::string &err_msg)>

using	string_view_t = fmt::basic_string_view< char >

using	memory_buf_t = fmt::basic_memory_buffer< char, 250 >

template<typename... Args>
using	format_string_t = fmt::format_string< Args... >

template<class T >
using	remove_cvref_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type

using	level_t = std::atomic< int >

using	default_factory = synchronous_factory

Enumerations
enum	async_overflow_policy { async_overflow_policy::block, async_overflow_policy::overrun_oldest }

enum	color_mode { color_mode::always, color_mode::automatic, color_mode::never }

enum	pattern_time_type { pattern_time_type::local, pattern_time_type::utc }

Functions
template<typename Sink , typename... SinkArgs>
std::shared_ptr< spdlog::logger >	create_async (std::string logger_name, SinkArgs &&... sink_args)

template<typename Sink , typename... SinkArgs>
std::shared_ptr< spdlog::logger >	create_async_nb (std::string logger_name, SinkArgs &&... sink_args)

void	init_thread_pool (size_t q_size, size_t thread_count, std::function< void()> on_thread_start, std::function< void()> on_thread_stop)

void	init_thread_pool (size_t q_size, size_t thread_count, std::function< void()> on_thread_start)

void	init_thread_pool (size_t q_size, size_t thread_count)

std::shared_ptr< spdlog::details::thread_pool >	thread_pool ()

SPDLOG_INLINE void	throw_spdlog_ex (const std::string &msg, int last_errno)

SPDLOG_INLINE void	throw_spdlog_ex (std::string msg)

template<typename Container >
details::dump_info< typename Container::const_iterator >	to_hex (const Container &container, size_t size_per_line=32)

template<typename It >
details::dump_info< It >	to_hex (const It range_begin, const It range_end, size_t size_per_line=32)

SPDLOG_INLINE void	swap (logger &a, logger &b)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	basic_logger_mt (const std::string &logger_name, const filename_t &filename, bool truncate=false, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	basic_logger_st (const std::string &logger_name, const filename_t &filename, bool truncate=false, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	daily_logger_mt (const std::string &logger_name, const filename_t &filename, int hour=0, int minute=0, bool truncate=false, uint16_t max_files=0, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	daily_logger_format_mt (const std::string &logger_name, const filename_t &filename, int hour=0, int minute=0, bool truncate=false, uint16_t max_files=0, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	daily_logger_st (const std::string &logger_name, const filename_t &filename, int hour=0, int minute=0, bool truncate=false, uint16_t max_files=0, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	daily_logger_format_st (const std::string &logger_name, const filename_t &filename, int hour=0, int minute=0, bool truncate=false, uint16_t max_files=0, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	hourly_logger_mt (const std::string &logger_name, const filename_t &filename, bool truncate=false, uint16_t max_files=0, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	hourly_logger_st (const std::string &logger_name, const filename_t &filename, bool truncate=false, uint16_t max_files=0, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	mongo_logger_mt (const std::string &logger_name, const std::string &db_name, const std::string &collection_name, const std::string &uri="mongodb://localhost:27017")

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	mongo_logger_st (const std::string &logger_name, const std::string &db_name, const std::string &collection_name, const std::string &uri="mongodb://localhost:27017")

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	null_logger_mt (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	null_logger_st (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	qt_logger_mt (const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method="append")

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	qt_logger_st (const std::string &logger_name, QTextEdit *qt_object, const std::string &meta_method="append")

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	qt_logger_mt (const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method="appendPlainText")

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	qt_logger_st (const std::string &logger_name, QPlainTextEdit *qt_object, const std::string &meta_method="appendPlainText")

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	qt_logger_mt (const std::string &logger_name, QObject *qt_object, const std::string &meta_method)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	qt_logger_st (const std::string &logger_name, QObject *qt_object, const std::string &meta_method)

template<typename Factory = spdlog::synchronous_factory>
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, bool rotate_on_open=false, const file_event_handlers &event_handlers={})

template<typename Factory = spdlog::synchronous_factory>
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, bool rotate_on_open=false, const file_event_handlers &event_handlers={})

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stdout_color_mt (const std::string &logger_name, color_mode mode)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stdout_color_st (const std::string &logger_name, color_mode mode)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stderr_color_mt (const std::string &logger_name, color_mode mode)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stderr_color_st (const std::string &logger_name, color_mode mode)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stdout_color_mt (const std::string &logger_name, color_mode mode=color_mode::automatic)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stdout_color_st (const std::string &logger_name, color_mode mode=color_mode::automatic)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stderr_color_mt (const std::string &logger_name, color_mode mode=color_mode::automatic)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stderr_color_st (const std::string &logger_name, color_mode mode=color_mode::automatic)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stdout_logger_mt (const std::string &logger_name)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stdout_logger_st (const std::string &logger_name)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stderr_logger_mt (const std::string &logger_name)

template<typename Factory >
SPDLOG_INLINE std::shared_ptr< logger >	stderr_logger_st (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stdout_logger_mt (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stdout_logger_st (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stderr_logger_mt (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	stderr_logger_st (const std::string &logger_name)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	syslog_logger_mt (const std::string &logger_name, const std::string &syslog_ident="", int syslog_option=0, int syslog_facility=LOG_USER, bool enable_formatting=false)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	syslog_logger_st (const std::string &logger_name, const std::string &syslog_ident="", int syslog_option=0, int syslog_facility=LOG_USER, bool enable_formatting=false)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	systemd_logger_mt (const std::string &logger_name, const std::string &ident="", bool enable_formatting=false)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	systemd_logger_st (const std::string &logger_name, const std::string &ident="", bool enable_formatting=false)

template<typename Factory = spdlog::synchronous_factory>
std::shared_ptr< logger >	udp_logger_mt (const std::string &logger_name, sinks::udp_sink_config skin_config)

SPDLOG_INLINE void	initialize_logger (std::shared_ptr< logger > logger)

SPDLOG_INLINE std::shared_ptr< logger >	get (const std::string &name)

SPDLOG_INLINE void	set_formatter (std::unique_ptr< spdlog::formatter > formatter)

SPDLOG_INLINE void	set_pattern (std::string pattern, pattern_time_type time_type)

SPDLOG_INLINE void	enable_backtrace (size_t n_messages)

SPDLOG_INLINE void	disable_backtrace ()

SPDLOG_INLINE void	dump_backtrace ()

SPDLOG_INLINE level::level_enum	get_level ()

SPDLOG_INLINE bool	should_log (level::level_enum log_level)

SPDLOG_INLINE void	set_level (level::level_enum log_level)

SPDLOG_INLINE void	flush_on (level::level_enum log_level)

SPDLOG_INLINE void	flush_every (std::chrono::seconds interval)

SPDLOG_INLINE void	set_error_handler (void(*handler)(const std::string &msg))

SPDLOG_INLINE void	register_logger (std::shared_ptr< logger > logger)

SPDLOG_INLINE void	apply_all (const std::function< void(std::shared_ptr< logger >)> &fun)

SPDLOG_INLINE void	drop (const std::string &name)

SPDLOG_INLINE void	drop_all ()

SPDLOG_INLINE void	shutdown ()

SPDLOG_INLINE void	set_automatic_registration (bool automatic_registration)

SPDLOG_INLINE std::shared_ptr< spdlog::logger >	default_logger ()

SPDLOG_INLINE spdlog::logger *	default_logger_raw ()

SPDLOG_INLINE void	set_default_logger (std::shared_ptr< spdlog::logger > default_logger)

template<typename Sink , typename... SinkArgs>
std::shared_ptr< spdlog::logger >	create (std::string logger_name, SinkArgs &&... sink_args)

template<typename... Args>
void	log (source_loc source, level::level_enum lvl, format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	log (level::level_enum lvl, format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	trace (format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	debug (format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	info (format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	warn (format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	error (format_string_t< Args... > fmt, Args &&... args)

template<typename... Args>
void	critical (format_string_t< Args... > fmt, Args &&... args)

template<typename T >
void	log (source_loc source, level::level_enum lvl, const T &msg)

template<typename T >
void	log (level::level_enum lvl, const T &msg)

template<typename T >
void	trace (const T &msg)

template<typename T >
void	debug (const T &msg)

template<typename T >
void	info (const T &msg)

template<typename T >
void	warn (const T &msg)

template<typename T >
void	error (const T &msg)

template<typename T >
void	critical (const T &msg)

Typedef Documentation

◆ async_factory

using spdlog::async_factory = typedef async_factory_impl<async_overflow_policy::block>

◆ async_factory_nonblock

using spdlog::async_factory_nonblock = typedef async_factory_impl<async_overflow_policy::overrun_oldest>

◆ default_factory

using spdlog::default_factory = typedef synchronous_factory

◆ err_handler

using spdlog::err_handler = typedef std::function<void(const std::string &err_msg)>

◆ filename_t

using spdlog::filename_t = typedef std::string

◆ format_string_t

template<typename... Args>

using spdlog::format_string_t = typedef fmt::format_string<Args...>

◆ level_t

using spdlog::level_t = typedef std::atomic<int>

◆ log_clock

using spdlog::log_clock = typedef std::chrono::system_clock

◆ memory_buf_t

using spdlog::memory_buf_t = typedef fmt::basic_memory_buffer<char, 250>

◆ remove_cvref_t

template<class T >

using spdlog::remove_cvref_t = typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type

◆ sink_ptr

using spdlog::sink_ptr = typedef std::shared_ptr<sinks::sink>

◆ sinks_init_list

using spdlog::sinks_init_list = typedef std::initializer_list<sink_ptr>

◆ string_view_t

using spdlog::string_view_t = typedef fmt::basic_string_view<char>

Enumeration Type Documentation

◆ async_overflow_policy

enum spdlog::async_overflow_policy

strong

Enumerator
block
overrun_oldest

◆ color_mode

enum spdlog::color_mode

strong

Enumerator
always
automatic
never

◆ pattern_time_type

enum spdlog::pattern_time_type

strong

Enumerator
local
utc

Function Documentation

◆ apply_all()

SPDLOG_API void spdlog::apply_all ( const std::function< void(std::shared_ptr< logger >)> & fun )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ basic_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::basic_logger_mt	(	const std::string &	logger_name,
		const filename_t &	filename,
		bool	truncate = `false`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

Here is the caller graph for this function:

◆ basic_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::basic_logger_st	(	const std::string &	logger_name,
		const filename_t &	filename,
		bool	truncate = `false`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

Here is the caller graph for this function:

◆ create()

template<typename Sink , typename... SinkArgs>

std::shared_ptr<spdlog::logger> spdlog::create	(	std::string	logger_name,
		SinkArgs &&...	sink_args
	)

inline

◆ create_async()

template<typename Sink , typename... SinkArgs>

std::shared_ptr<spdlog::logger> spdlog::create_async	(	std::string	logger_name,
		SinkArgs &&...	sink_args
	)

inline

◆ create_async_nb()

template<typename Sink , typename... SinkArgs>

std::shared_ptr<spdlog::logger> spdlog::create_async_nb	(	std::string	logger_name,
		SinkArgs &&...	sink_args
	)

inline

◆ critical() [1/2]

template<typename T >

void spdlog::critical ( const T & msg )

inline

Here is the call graph for this function:

◆ critical() [2/2]

template<typename... Args>

void spdlog::critical	(	format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ daily_logger_format_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::daily_logger_format_mt	(	const std::string &	logger_name,
		const filename_t &	filename,
		int	hour = `0`,
		int	minute = `0`,
		bool	truncate = `false`,
		uint16_t	max_files = `0`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

◆ daily_logger_format_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::daily_logger_format_st	(	const std::string &	logger_name,
		const filename_t &	filename,
		int	hour = `0`,
		int	minute = `0`,
		bool	truncate = `false`,
		uint16_t	max_files = `0`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

◆ daily_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::daily_logger_mt	(	const std::string &	logger_name,
		const filename_t &	filename,
		int	hour = `0`,
		int	minute = `0`,
		bool	truncate = `false`,
		uint16_t	max_files = `0`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

Here is the caller graph for this function:

◆ daily_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::daily_logger_st	(	const std::string &	logger_name,
		const filename_t &	filename,
		int	hour = `0`,
		int	minute = `0`,
		bool	truncate = `false`,
		uint16_t	max_files = `0`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

Here is the caller graph for this function:

◆ debug() [1/2]

template<typename T >

void spdlog::debug ( const T & msg )

inline

Here is the call graph for this function:

◆ debug() [2/2]

template<typename... Args>

void spdlog::debug	(	format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ default_logger()

SPDLOG_API std::shared_ptr< spdlog::logger > spdlog::default_logger ( )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ default_logger_raw()

SPDLOG_API spdlog::logger * spdlog::default_logger_raw ( )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disable_backtrace()

SPDLOG_API void spdlog::disable_backtrace ( )

Here is the call graph for this function:

◆ drop()

SPDLOG_API void spdlog::drop ( const std::string & name )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drop_all()

SPDLOG_API void spdlog::drop_all ( )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump_backtrace()

SPDLOG_API void spdlog::dump_backtrace ( )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable_backtrace()

SPDLOG_API void spdlog::enable_backtrace ( size_t n_messages )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ error() [1/2]

template<typename T >

void spdlog::error ( const T & msg )

inline

Here is the call graph for this function:

◆ error() [2/2]

template<typename... Args>

void spdlog::error	(	format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_every()

SPDLOG_API void spdlog::flush_every ( std::chrono::seconds interval )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flush_on()

SPDLOG_API void spdlog::flush_on ( level::level_enum log_level )

Here is the call graph for this function:

◆ get()

SPDLOG_API std::shared_ptr< logger > spdlog::get ( const std::string & name )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_level()

SPDLOG_API level::level_enum spdlog::get_level ( )

Here is the call graph for this function:

◆ hourly_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::hourly_logger_mt	(	const std::string &	logger_name,
		const filename_t &	filename,
		bool	truncate = `false`,
		uint16_t	max_files = `0`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

◆ hourly_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::hourly_logger_st	(	const std::string &	logger_name,
		const filename_t &	filename,
		bool	truncate = `false`,
		uint16_t	max_files = `0`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

◆ info() [1/2]

template<typename T >

void spdlog::info ( const T & msg )

inline

Here is the call graph for this function:

◆ info() [2/2]

template<typename... Args>

void spdlog::info	(	format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_thread_pool() [1/3]

void spdlog::init_thread_pool	(	size_t	q_size,
		size_t	thread_count
	)

inline

Here is the call graph for this function:

◆ init_thread_pool() [2/3]

void spdlog::init_thread_pool	(	size_t	q_size,
		size_t	thread_count,
		std::function< void()>	on_thread_start
	)

inline

Here is the call graph for this function:

◆ init_thread_pool() [3/3]

void spdlog::init_thread_pool	(	size_t	q_size,
		size_t	thread_count,
		std::function< void()>	on_thread_start,
		std::function< void()>	on_thread_stop
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_logger()

SPDLOG_API void spdlog::initialize_logger ( std::shared_ptr< logger > logger )

Here is the call graph for this function:

◆ log() [1/4]

template<typename T >

void spdlog::log	(	level::level_enum	lvl,
		const T &	msg
	)

inline

Here is the call graph for this function:

◆ log() [2/4]

template<typename... Args>

void spdlog::log	(	level::level_enum	lvl,
		format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

◆ log() [3/4]

template<typename T >

void spdlog::log	(	source_loc	source,
		level::level_enum	lvl,
		const T &	msg
	)

inline

Here is the call graph for this function:

◆ log() [4/4]

template<typename... Args>

void spdlog::log	(	source_loc	source,
		level::level_enum	lvl,
		format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mongo_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::mongo_logger_mt	(	const std::string &	logger_name,
		const std::string &	db_name,
		const std::string &	collection_name,
		const std::string &	uri = `"mongodb://localhost:27017"`
	)

inline

◆ mongo_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::mongo_logger_st	(	const std::string &	logger_name,
		const std::string &	db_name,
		const std::string &	collection_name,
		const std::string &	uri = `"mongodb://localhost:27017"`
	)

inline

◆ null_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::null_logger_mt ( const std::string & logger_name )

inline

Here is the caller graph for this function:

◆ null_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::null_logger_st ( const std::string & logger_name )

inline

Here is the caller graph for this function:

◆ qt_logger_mt() [1/3]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::qt_logger_mt	(	const std::string &	logger_name,
		QObject *	qt_object,
		const std::string &	meta_method
	)

inline

◆ qt_logger_mt() [2/3]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::qt_logger_mt	(	const std::string &	logger_name,
		QPlainTextEdit *	qt_object,
		const std::string &	meta_method = `"appendPlainText"`
	)

inline

◆ qt_logger_mt() [3/3]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::qt_logger_mt	(	const std::string &	logger_name,
		QTextEdit *	qt_object,
		const std::string &	meta_method = `"append"`
	)

inline

◆ qt_logger_st() [1/3]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::qt_logger_st	(	const std::string &	logger_name,
		QObject *	qt_object,
		const std::string &	meta_method
	)

inline

◆ qt_logger_st() [2/3]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::qt_logger_st	(	const std::string &	logger_name,
		QPlainTextEdit *	qt_object,
		const std::string &	meta_method = `"appendPlainText"`
	)

inline

◆ qt_logger_st() [3/3]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::qt_logger_st	(	const std::string &	logger_name,
		QTextEdit *	qt_object,
		const std::string &	meta_method = `"append"`
	)

inline

◆ register_logger()

SPDLOG_API void spdlog::register_logger ( std::shared_ptr< logger > logger )

Here is the call graph for this function:

◆ rotating_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::rotating_logger_mt	(	const std::string &	logger_name,
		const filename_t &	filename,
		size_t	max_file_size,
		size_t	max_files,
		bool	rotate_on_open = `false`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

Here is the caller graph for this function:

◆ rotating_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::rotating_logger_st	(	const std::string &	logger_name,
		const filename_t &	filename,
		size_t	max_file_size,
		size_t	max_files,
		bool	rotate_on_open = `false`,
		const file_event_handlers &	event_handlers = `{}`
	)

inline

Here is the caller graph for this function:

◆ set_automatic_registration()

SPDLOG_API void spdlog::set_automatic_registration ( bool automatic_registration )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_default_logger()

SPDLOG_API void spdlog::set_default_logger ( std::shared_ptr< spdlog::logger > default_logger )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_error_handler()

SPDLOG_API void spdlog::set_error_handler ( void(*)(const std::string &msg) handler )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_formatter()

SPDLOG_API void spdlog::set_formatter ( std::unique_ptr< spdlog::formatter > formatter )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_level()

SPDLOG_API void spdlog::set_level ( level::level_enum log_level )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_pattern()

SPDLOG_API void spdlog::set_pattern	(	std::string	pattern,
		pattern_time_type	time_type
	)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ should_log()

SPDLOG_API bool spdlog::should_log ( level::level_enum log_level )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shutdown()

SPDLOG_API void spdlog::shutdown ( )

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stderr_color_mt() [1/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stderr_color_mt	(	const std::string &	logger_name,
		color_mode	mode
	)

◆ stderr_color_mt() [2/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stderr_color_mt	(	const std::string &	logger_name,
		color_mode	mode = `color_mode::automatic`
	)

◆ stderr_color_st() [1/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stderr_color_st	(	const std::string &	logger_name,
		color_mode	mode
	)

◆ stderr_color_st() [2/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stderr_color_st	(	const std::string &	logger_name,
		color_mode	mode = `color_mode::automatic`
	)

◆ stderr_logger_mt() [1/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stderr_logger_mt ( const std::string & logger_name )

◆ stderr_logger_mt() [2/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stderr_logger_mt ( const std::string & logger_name )

◆ stderr_logger_st() [1/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stderr_logger_st ( const std::string & logger_name )

◆ stderr_logger_st() [2/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stderr_logger_st ( const std::string & logger_name )

◆ stdout_color_mt() [1/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stdout_color_mt	(	const std::string &	logger_name,
		color_mode	mode
	)

Here is the caller graph for this function:

◆ stdout_color_mt() [2/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stdout_color_mt	(	const std::string &	logger_name,
		color_mode	mode = `color_mode::automatic`
	)

Here is the caller graph for this function:

◆ stdout_color_st() [1/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stdout_color_st	(	const std::string &	logger_name,
		color_mode	mode
	)

◆ stdout_color_st() [2/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stdout_color_st	(	const std::string &	logger_name,
		color_mode	mode = `color_mode::automatic`
	)

◆ stdout_logger_mt() [1/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stdout_logger_mt ( const std::string & logger_name )

◆ stdout_logger_mt() [2/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stdout_logger_mt ( const std::string & logger_name )

◆ stdout_logger_st() [1/2]

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::stdout_logger_st ( const std::string & logger_name )

Here is the caller graph for this function:

◆ stdout_logger_st() [2/2]

template<typename Factory >

SPDLOG_INLINE std::shared_ptr<logger> spdlog::stdout_logger_st ( const std::string & logger_name )

Here is the caller graph for this function:

◆ swap()

void spdlog::swap	(	logger &	a,
		logger &	b
	)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ syslog_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::syslog_logger_mt	(	const std::string &	logger_name,
		const std::string &	syslog_ident = `""`,
		int	syslog_option = `0`,
		int	syslog_facility = `LOG_USER`,
		bool	enable_formatting = `false`
	)

inline

Here is the caller graph for this function:

◆ syslog_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::syslog_logger_st	(	const std::string &	logger_name,
		const std::string &	syslog_ident = `""`,
		int	syslog_option = `0`,
		int	syslog_facility = `LOG_USER`,
		bool	enable_formatting = `false`
	)

inline

◆ systemd_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::systemd_logger_mt	(	const std::string &	logger_name,
		const std::string &	ident = `""`,
		bool	enable_formatting = `false`
	)

inline

◆ systemd_logger_st()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::systemd_logger_st	(	const std::string &	logger_name,
		const std::string &	ident = `""`,
		bool	enable_formatting = `false`
	)

inline

◆ thread_pool()

std::shared_ptr<spdlog::details::thread_pool> spdlog::thread_pool ( )

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ throw_spdlog_ex() [1/2]

void spdlog::throw_spdlog_ex	(	const std::string &	msg,
		int	last_errno
	)

Here is the caller graph for this function:

◆ throw_spdlog_ex() [2/2]

void spdlog::throw_spdlog_ex ( std::string msg )

◆ to_hex() [1/2]

template<typename Container >

details::dump_info<typename Container::const_iterator> spdlog::to_hex	(	const Container &	container,
		size_t	size_per_line = `32`
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_hex() [2/2]

template<typename It >

details::dump_info<It> spdlog::to_hex	(	const It	range_begin,
		const It	range_end,
		size_t	size_per_line = `32`
	)

inline

Here is the call graph for this function:

◆ trace() [1/2]

template<typename T >

void spdlog::trace ( const T & msg )

inline

Here is the call graph for this function:

◆ trace() [2/2]

template<typename... Args>

void spdlog::trace	(	format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

◆ udp_logger_mt()

template<typename Factory = spdlog::synchronous_factory>

std::shared_ptr<logger> spdlog::udp_logger_mt	(	const std::string &	logger_name,
		sinks::udp_sink_config	skin_config
	)

inline

Here is the caller graph for this function:

◆ warn() [1/2]

template<typename T >

void spdlog::warn ( const T & msg )

inline

Here is the call graph for this function:

◆ warn() [2/2]

template<typename... Args>

void spdlog::warn	(	format_string_t< Args... >	fmt,
		Args &&...	args
	)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ async_factory

◆ async_factory_nonblock

◆ default_factory

◆ err_handler

◆ filename_t

◆ format_string_t

◆ level_t

◆ log_clock

◆ memory_buf_t

◆ remove_cvref_t

◆ sink_ptr

◆ sinks_init_list

◆ string_view_t

Enumeration Type Documentation

◆ async_overflow_policy

◆ color_mode

◆ pattern_time_type

Function Documentation

◆ apply_all()

◆ basic_logger_mt()

◆ basic_logger_st()

◆ create()

◆ create_async()

◆ create_async_nb()

◆ critical() [1/2]

◆ critical() [2/2]

◆ daily_logger_format_mt()

◆ daily_logger_format_st()

◆ daily_logger_mt()

◆ daily_logger_st()

◆ debug() [1/2]

◆ debug() [2/2]

◆ default_logger()

◆ default_logger_raw()

◆ disable_backtrace()

◆ drop()

◆ drop_all()

◆ dump_backtrace()

◆ enable_backtrace()

◆ error() [1/2]

◆ error() [2/2]

◆ flush_every()

◆ flush_on()

◆ get()

◆ get_level()

◆ hourly_logger_mt()

◆ hourly_logger_st()

◆ info() [1/2]

◆ info() [2/2]

◆ init_thread_pool() [1/3]

◆ init_thread_pool() [2/3]

◆ init_thread_pool() [3/3]

◆ initialize_logger()

◆ log() [1/4]

◆ log() [2/4]

◆ log() [3/4]

◆ log() [4/4]

◆ mongo_logger_mt()

◆ mongo_logger_st()

◆ null_logger_mt()

◆ null_logger_st()

◆ qt_logger_mt() [1/3]

◆ qt_logger_mt() [2/3]

◆ qt_logger_mt() [3/3]

◆ qt_logger_st() [1/3]

◆ qt_logger_st() [2/3]

◆ qt_logger_st() [3/3]

◆ register_logger()

◆ rotating_logger_mt()

◆ rotating_logger_st()

◆ set_automatic_registration()

◆ set_default_logger()

◆ set_error_handler()

◆ set_formatter()