kcenon::pacs::di::ILogger Class Reference

Abstract logger interface for dependency injection. More...

#include <ilogger.h>

Inheritance diagram for kcenon::pacs::di::ILogger:

Collaboration diagram for kcenon::pacs::di::ILogger:

Public Member Functions
virtual	~ILogger ()=default
virtual void	trace (std::string_view message)=0
	Log a trace-level message.
virtual void	debug (std::string_view message)=0
	Log a debug-level message.
virtual void	info (std::string_view message)=0
	Log an info-level message.
virtual void	warn (std::string_view message)=0
	Log a warning-level message.
virtual void	error (std::string_view message)=0
	Log an error-level message.
virtual void	fatal (std::string_view message)=0
	Log a fatal-level message.
virtual bool	is_enabled (integration::log_level level) const noexcept=0
	Check if a log level is enabled.
template<typename... Args>
void	trace_fmt (kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args)
	Log a formatted trace-level message.
template<typename... Args>
void	debug_fmt (kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args)
	Log a formatted debug-level message.
template<typename... Args>
void	info_fmt (kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args)
	Log a formatted info-level message.
template<typename... Args>
void	warn_fmt (kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args)
	Log a formatted warning-level message.
template<typename... Args>
void	error_fmt (kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args)
	Log a formatted error-level message.
template<typename... Args>
void	fatal_fmt (kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args)
	Log a formatted fatal-level message.

Protected Member Functions
	ILogger ()=default
	ILogger (const ILogger &)=default
ILogger &	operator= (const ILogger &)=default
	ILogger (ILogger &&)=default
ILogger &	operator= (ILogger &&)=default

Detailed Description

Abstract logger interface for dependency injection.

This interface provides a standardized logging API that can be injected into DICOM services. It supports all standard log levels and enables testable code through mock implementations.

Thread Safety:

• All methods must be thread-safe in concrete implementations
• Logging from multiple threads should be properly serialized

See also

Issue #309 - Full Adoption of ILogger Interface

Definition at line 45 of file ilogger.h.

Constructor & Destructor Documentation

~ILogger()

virtual kcenon::pacs::di::ILogger::~ILogger ( )

virtualdefault

ILogger() [1/3]

kcenon::pacs::di::ILogger::ILogger ( )

protecteddefault

ILogger() [2/3]

kcenon::pacs::di::ILogger::ILogger ( const ILogger & )

protecteddefault

ILogger() [3/3]

kcenon::pacs::di::ILogger::ILogger ( ILogger && )

protecteddefault

Member Function Documentation

debug()

virtual void kcenon::pacs::di::ILogger::debug ( std::string_view message )

pure virtual

Log a debug-level message.

Parameters

message

The message to log

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by debug_fmt().

Here is the caller graph for this function:

debug_fmt()

template<typename... Args>

void kcenon::pacs::di::ILogger::debug_fmt ( kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args )

inline

Log a formatted debug-level message.

Definition at line 118 of file ilogger.h.

                                                                               {
        if (is_enabled(integration::log_level::debug)) {
            debug(kcenon::pacs::compat::format(fmt, std::forward<Args>(args)...));
        }
    }

References debug(), kcenon::pacs::integration::debug, and is_enabled().

Here is the call graph for this function:

error()

virtual void kcenon::pacs::di::ILogger::error ( std::string_view message )

pure virtual

Log an error-level message.

Parameters

message

The message to log

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by error_fmt().

Here is the caller graph for this function:

error_fmt()

template<typename... Args>

void kcenon::pacs::di::ILogger::error_fmt ( kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args )

inline

Log a formatted error-level message.

Definition at line 148 of file ilogger.h.

                                                                               {
        if (is_enabled(integration::log_level::error)) {
            error(kcenon::pacs::compat::format(fmt, std::forward<Args>(args)...));
        }
    }

References error(), kcenon::pacs::integration::error, and is_enabled().

Here is the call graph for this function:

fatal()

virtual void kcenon::pacs::di::ILogger::fatal ( std::string_view message )

pure virtual

Log a fatal-level message.

Parameters

message

The message to log

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by fatal_fmt().

Here is the caller graph for this function:

fatal_fmt()

template<typename... Args>

void kcenon::pacs::di::ILogger::fatal_fmt ( kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args )

inline

Log a formatted fatal-level message.

Definition at line 158 of file ilogger.h.

                                                                               {
        if (is_enabled(integration::log_level::fatal)) {
            fatal(kcenon::pacs::compat::format(fmt, std::forward<Args>(args)...));
        }
    }

References fatal(), kcenon::pacs::integration::fatal, and is_enabled().

Here is the call graph for this function:

info()

virtual void kcenon::pacs::di::ILogger::info ( std::string_view message )

pure virtual

Log an info-level message.

Parameters

message

The message to log

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by info_fmt().

Here is the caller graph for this function:

info_fmt()

template<typename... Args>

void kcenon::pacs::di::ILogger::info_fmt ( kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args )

inline

Log a formatted info-level message.

Definition at line 128 of file ilogger.h.

                                                                              {
        if (is_enabled(integration::log_level::info)) {
            info(kcenon::pacs::compat::format(fmt, std::forward<Args>(args)...));
        }
    }

References info(), kcenon::pacs::integration::info, and is_enabled().

Here is the call graph for this function:

is_enabled()

virtual bool kcenon::pacs::di::ILogger::is_enabled ( integration::log_level level ) const

nodiscardpure virtualnoexcept

Check if a log level is enabled.

Parameters

level

The level to check

Returns

true if messages at this level will be logged

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by debug_fmt(), error_fmt(), fatal_fmt(), info_fmt(), trace_fmt(), and warn_fmt().

Here is the caller graph for this function:

operator=() [1/2]

ILogger & kcenon::pacs::di::ILogger::operator= ( const ILogger & )

protecteddefault

operator=() [2/2]

ILogger & kcenon::pacs::di::ILogger::operator= ( ILogger && )

protecteddefault

trace()

virtual void kcenon::pacs::di::ILogger::trace ( std::string_view message )

pure virtual

Log a trace-level message.

Parameters

message

The message to log

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by trace_fmt().

Here is the caller graph for this function:

trace_fmt()

template<typename... Args>

void kcenon::pacs::di::ILogger::trace_fmt ( kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args )

inline

Log a formatted trace-level message.

Definition at line 108 of file ilogger.h.

                                                                               {
        if (is_enabled(integration::log_level::trace)) {
            trace(kcenon::pacs::compat::format(fmt, std::forward<Args>(args)...));
        }
    }

References is_enabled(), trace(), and kcenon::pacs::integration::trace.

Here is the call graph for this function:

warn()

virtual void kcenon::pacs::di::ILogger::warn ( std::string_view message )

pure virtual

Log a warning-level message.

Parameters

message

The message to log

Implemented in kcenon::pacs::di::LoggerService, and kcenon::pacs::di::NullLogger.

Referenced by warn_fmt().

Here is the caller graph for this function:

warn_fmt()

template<typename... Args>

void kcenon::pacs::di::ILogger::warn_fmt ( kcenon::pacs::compat::format_string< Args... > fmt, Args &&... args )

inline

Log a formatted warning-level message.

Definition at line 138 of file ilogger.h.

                                                                              {
        if (is_enabled(integration::log_level::warn)) {
            warn(kcenon::pacs::compat::format(fmt, std::forward<Args>(args)...));
        }
    }

References is_enabled(), warn(), and kcenon::pacs::integration::warn.

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• include/kcenon/pacs/di/ilogger.h