kcenon::logger::adapters::logger_adapter Class Reference

Adapter to expose logger as common::interfaces::ILogger. More...

#include <common_logger_adapter.h>

Inheritance diagram for kcenon::logger::adapters::logger_adapter:

Collaboration diagram for kcenon::logger::adapters::logger_adapter:

Public Member Functions
	logger_adapter (std::shared_ptr< kcenon::logger::logger > lgr)
	Construct adapter with logger instance.
	~logger_adapter () override=default
::common::VoidResult	log (::common::interfaces::log_level level, const std::string &message) override
	Log a message with specified level.
::common::VoidResult	log_with_location (::common::interfaces::log_level level, const std::string &message, const std::string &file, int line, const std::string &function) override
	Log a message with source location information.
::common::VoidResult	log_entry (const ::common::interfaces::log_entry &entry) override
	Log a structured entry.
::common::VoidResult	set_level (::common::interfaces::log_level level) override
	Set the minimum log level.
::common::interfaces::log_level	get_level () const override
	Get the current log level.
::common::VoidResult	flush () override
	Flush all pending log messages.
::common::VoidResult	register_callback (std::function< void(const ::common::interfaces::log_entry &)> callback) override
	Register a callback for log events.
	logger_adapter (std::shared_ptr< logger > logger_instance)
	Constructor with logger instance.
	logger_adapter ()
	Default constructor - creates a default logger.
void	log (log_level level, std::string_view message)
	Log a message with the specified level.
bool	initialize ()
	Initialize the adapter.
void	shutdown ()
	Shutdown the adapter.
bool	is_running () const
	Check if the adapter is running.
std::string	name () const
	Get the adapter name.
std::shared_ptr< logger >	get_logger () const
	Get the underlying logger.
void	set_level (log_level level)
	Set minimum log level.

Private Attributes
std::shared_ptr< kcenon::logger::logger >	logger_
std::shared_ptr< logger >	logger_
bool	is_running_ {false}

Detailed Description

Adapter to expose logger as common::interfaces::ILogger.

Standalone logger adapter.

Note

For thread_system integration, use common_logger_adapter.h which provides adapters for kcenon::common::interfaces::ILogger (the unified interface used by thread_system v3.0+)

Definition at line 34 of file logger_adapter.h.

Constructor & Destructor Documentation

logger_adapter() [1/3]

kcenon::logger::adapters::logger_adapter::logger_adapter ( std::shared_ptr< kcenon::logger::logger > lgr )

inlineexplicit

Construct adapter with logger instance.

Definition at line 85 of file common_logger_adapter.h.

        : logger_(lgr) {}

~logger_adapter()

kcenon::logger::adapters::logger_adapter::~logger_adapter ( )

overridedefault

logger_adapter() [2/3]

kcenon::logger::adapters::logger_adapter::logger_adapter ( std::shared_ptr< logger > logger_instance )

inlineexplicit

Constructor with logger instance.

Parameters

logger

Logger instance to adapt

Definition at line 40 of file logger_adapter.h.

        : logger_(std::move(logger_instance)) {
    }

logger_adapter() [3/3]

kcenon::logger::adapters::logger_adapter::logger_adapter ( )

inline

Default constructor - creates a default logger.

Definition at line 47 of file logger_adapter.h.

                     : logger_(std::make_shared<logger>()) {
    }

Member Function Documentation

flush()

::common::VoidResult kcenon::logger::adapters::logger_adapter::flush ( )

inlineoverride

Flush all pending log messages.

Note

No try-catch needed - logger operations are noexcept

Definition at line 187 of file common_logger_adapter.h.

                                      {
        if (!logger_) {
            return ::common::error_info(1, "Logger not initialized", "logger_system");
        }
 
        // Logger operations are designed to be noexcept
        logger_->flush();
        return ::common::VoidResult(std::monostate{});
    }

References kcenon::logger::logger::flush(), and logger_.

Here is the call graph for this function:

get_level()

::common::interfaces::log_level kcenon::logger::adapters::logger_adapter::get_level ( ) const

inlineoverride

Get the current log level.

Definition at line 175 of file common_logger_adapter.h.

                                                         {
        if (!logger_) {
            return ::common::interfaces::log_level::off;
        }
 
        return to_common_level(logger_->get_level());
    }

References kcenon::logger::logger::get_level(), logger_, and kcenon::logger::adapters::to_common_level().

Here is the call graph for this function:

get_logger()

std::shared_ptr< logger > kcenon::logger::adapters::logger_adapter::get_logger ( ) const

inline

Get the underlying logger.

Returns

Logger instance

Definition at line 104 of file logger_adapter.h.

                                             {
        return logger_;
    }

References logger_.

initialize()

bool kcenon::logger::adapters::logger_adapter::initialize ( )

inline

Initialize the adapter.

Returns

true if initialization succeeded

Definition at line 66 of file logger_adapter.h.

                      {
        if (logger_) {
            is_running_ = true;
            return true;
        }
        return false;
    }

References is_running_, and logger_.

is_running()

bool kcenon::logger::adapters::logger_adapter::is_running ( ) const

inline

Check if the adapter is running.

Returns

true if running

Definition at line 88 of file logger_adapter.h.

                            {
        return is_running_ && logger_ != nullptr;
    }

References is_running_, and logger_.

log() [1/2]

::common::VoidResult kcenon::logger::adapters::logger_adapter::log ( ::common::interfaces::log_level level, const std::string & message )

inlineoverride

Log a message with specified level.

Note

No try-catch needed - logger operations are noexcept

Definition at line 94 of file common_logger_adapter.h.

                                                                {
        if (!logger_) {
            return ::common::error_info(1, "Logger not initialized", "logger_system");
        }
 
        // Logger operations are designed to be noexcept - simply call and return success
        logger_->log(from_common_level(level), message);
        return ::common::VoidResult(std::monostate{});
    }

References kcenon::logger::adapters::from_common_level(), kcenon::logger::logger::log(), and logger_.

Here is the call graph for this function:

log() [2/2]

void kcenon::logger::adapters::logger_adapter::log ( log_level level, std::string_view message )

inline

Log a message with the specified level.

Parameters

level	Log level
message	Message to log

Definition at line 55 of file logger_adapter.h.

                                                      {
        if (!logger_) {
            return;
        }
        logger_->log(level, std::string(message));
    }

References kcenon::logger::logger::log(), and logger_.

Here is the call graph for this function:

log_entry()

::common::VoidResult kcenon::logger::adapters::logger_adapter::log_entry ( const ::common::interfaces::log_entry & entry )

inlineoverride

Log a structured entry.

Note

No try-catch needed - logger operations are noexcept

Definition at line 136 of file common_logger_adapter.h.

                                                         {
        if (!logger_) {
            return ::common::error_info(1, "Logger not initialized", "logger_system");
        }
 
        // Format the entry with location if available
        try {
            std::string message = entry.message;
            if (!entry.file.empty()) {
                message = std::format("[{}:{}:{}] {}",
                    entry.file, entry.line, entry.function, entry.message);
            }
 
            logger_->log(from_common_level(entry.level), message);
        } catch (const std::exception& e) {
            // Only format can throw
            return ::common::error_info(2, std::string("Format error: ") + e.what(), "logger_system");
        }
        return ::common::VoidResult(std::monostate{});
    }

References kcenon::logger::adapters::from_common_level(), kcenon::logger::logger::log(), and logger_.

Here is the call graph for this function:

log_with_location()

::common::VoidResult kcenon::logger::adapters::logger_adapter::log_with_location ( ::common::interfaces::log_level level, const std::string & message, const std::string & file, int line, const std::string & function )

inlineoverride

Log a message with source location information.

Note

No try-catch needed - logger operations are noexcept

Definition at line 109 of file common_logger_adapter.h.

                                            {
        if (!logger_) {
            return ::common::error_info(1, "Logger not initialized", "logger_system");
        }
 
        // Create formatted message with location info
        // Logger operations are noexcept - format may throw but we catch at API boundary
        try {
            std::string formatted = std::format("[{}:{}:{}] {}",
                file, line, function, message);
            logger_->log(from_common_level(level), formatted);
        } catch (const std::exception& e) {
            // Only format can throw - return error for format failure
            return ::common::error_info(2, std::string("Format error: ") + e.what(), "logger_system");
        }
        return ::common::VoidResult(std::monostate{});
    }

References kcenon::logger::adapters::from_common_level(), kcenon::logger::logger::log(), and logger_.

Here is the call graph for this function:

name()

std::string kcenon::logger::adapters::logger_adapter::name ( ) const

inline

Get the adapter name.

Returns

"LoggerAdapter"

Definition at line 96 of file logger_adapter.h.

                           {
        return "LoggerAdapter";
    }

register_callback()

::common::VoidResult kcenon::logger::adapters::logger_adapter::register_callback ( std::function< void(const ::common::interfaces::log_entry &)> callback )

inlineoverride

Register a callback for log events.

Definition at line 200 of file common_logger_adapter.h.

                                                                               {
        if (!logger_) {
            return ::common::error_info(1, "Logger not initialized", "logger_system");
        }
 
        // Note: This requires extending the logger_system to support callbacks
        // For now, return success as placeholder
        return ::common::VoidResult(std::monostate{});
    }

References logger_.

set_level() [1/2]

::common::VoidResult kcenon::logger::adapters::logger_adapter::set_level ( ::common::interfaces::log_level level )

inlineoverride

Set the minimum log level.

Note

No try-catch needed - logger operations are noexcept

Definition at line 162 of file common_logger_adapter.h.

                                                                         {
        if (!logger_) {
            return ::common::error_info(1, "Logger not initialized", "logger_system");
        }
 
        // Logger operations are designed to be noexcept
        logger_->set_level(from_common_level(level));
        return ::common::VoidResult(std::monostate{});
    }

References kcenon::logger::adapters::from_common_level(), logger_, and kcenon::logger::logger::set_level().

Here is the call graph for this function:

set_level() [2/2]

void kcenon::logger::adapters::logger_adapter::set_level ( log_level level )

inline

Set minimum log level.

Parameters

level

Minimum level to log

Definition at line 112 of file logger_adapter.h.

                                    {
        if (logger_) {
            logger_->set_level(level);
        }
    }

References logger_, and kcenon::logger::logger::set_level().

Here is the call graph for this function:

shutdown()

void kcenon::logger::adapters::logger_adapter::shutdown ( )

inline

Shutdown the adapter.

Definition at line 77 of file logger_adapter.h.

                    {
        if (logger_) {
            logger_->flush();
        }
        is_running_ = false;
    }

References kcenon::logger::logger::flush(), is_running_, and logger_.

Here is the call graph for this function:

Member Data Documentation

is_running_

bool kcenon::logger::adapters::logger_adapter::is_running_ {false}

private

Definition at line 120 of file logger_adapter.h.

{false};

Referenced by initialize(), is_running(), and shutdown().

logger_ [1/2]

std::shared_ptr<kcenon::logger::logger> kcenon::logger::adapters::logger_adapter::logger_

private

Definition at line 212 of file common_logger_adapter.h.

Referenced by flush(), get_level(), get_logger(), initialize(), is_running(), log(), log(), log_entry(), log_with_location(), register_callback(), set_level(), set_level(), and shutdown().

logger_ [2/2]

std::shared_ptr<logger> kcenon::logger::adapters::logger_adapter::logger_

private

Definition at line 119 of file logger_adapter.h.

---

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

• include/kcenon/logger/adapters/common_logger_adapter.h
• include/kcenon/logger/adapters/logger_adapter.h