kcenon::logger::file_writer Class Reference

Core file writer for logging to files. More...

#include <file_writer.h>

Inheritance diagram for kcenon::logger::file_writer:

Collaboration diagram for kcenon::logger::file_writer:

Public Member Functions
	file_writer (const std::string &filename, bool append=true, std::unique_ptr< log_formatter_interface > formatter=nullptr)
	Constructor.
	~file_writer () override
	Destructor.
	file_writer (const file_writer &)=delete
file_writer &	operator= (const file_writer &)=delete
	file_writer (file_writer &&)=delete
file_writer &	operator= (file_writer &&)=delete
common::VoidResult	write (const log_entry &entry) override
	Write a log entry to file.
common::VoidResult	flush () override
	Flush file stream.
common::VoidResult	close () override
	Close the file.
std::string	get_name () const override
	Get writer name.
bool	is_open () const override
	Check if file is open.
bool	is_healthy () const override
	Check if writer is healthy.
size_t	get_file_size () const
	Get current file size.
Public Member Functions inherited from kcenon::logger::log_writer_interface
virtual	~log_writer_interface ()=default

Protected Member Functions
std::string	format_entry (const log_entry &entry) const
	Format a log entry using the current formatter.
common::VoidResult	open_internal ()
	Open the file (internal, caller must hold mutex)
void	close_internal ()
	Close the file (internal, caller must hold mutex)
std::mutex &	get_mutex () const
	Access the writer mutex for extended operations.

Protected Attributes
std::string	filename_
bool	append_mode_
std::ofstream	file_stream_
std::atomic< bool >	is_open_ {false}
std::atomic< size_t >	bytes_written_ {0}
std::unique_ptr< log_formatter_interface >	formatter_
std::mutex	mutex_

Additional Inherited Members
Static Public Attributes inherited from kcenon::logger::sync_writer_tag
static constexpr writer_category	category = writer_category::synchronous

Detailed Description

Core file writer for logging to files.

Pure file I/O implementation with direct mutex management. Designed to serve as the base layer in Decorator pattern compositions.

Thread-safe with internal mutex synchronization.

Category: Synchronous (blocking I/O to file)

Since

1.0.0

1.3.0 Refactored to use thread_safe_writer base class

1.4.0 Added sync_writer_tag for category classification

4.0.0 Refactored for Decorator pattern with simplified inheritance

4.1.0 Directly implements log_writer_interface as core writer

Examples

decorator_usage.cpp.

Definition at line 44 of file file_writer.h.

Constructor & Destructor Documentation

file_writer() [1/3]

kcenon::logger::file_writer::file_writer ( const std::string & filename, bool append = true, std::unique_ptr< log_formatter_interface > formatter = nullptr )

explicit

Constructor.

Parameters

filename	Path to the log file
append	Whether to append to existing file (default: true)
formatter	Custom log formatter (default: timestamp formatter)

Definition at line 14 of file file_writer.cpp.

    : filename_(filename)
    , append_mode_(append)
    , formatter_(formatter ? std::move(formatter) : std::make_unique<timestamp_formatter>()) {
    std::lock_guard<std::mutex> lock(mutex_);
    open_internal();
}

References mutex_, and open_internal().

Here is the call graph for this function:

~file_writer()

kcenon::logger::file_writer::~file_writer ( )

override

Destructor.

Definition at line 24 of file file_writer.cpp.

                          {
    std::lock_guard<std::mutex> lock(mutex_);
    close_internal();
}

References close_internal(), and mutex_.

Here is the call graph for this function:

file_writer() [2/3]

kcenon::logger::file_writer::file_writer ( const file_writer & )

delete

file_writer() [3/3]

kcenon::logger::file_writer::file_writer ( file_writer && )

delete

Member Function Documentation

close()

common::VoidResult kcenon::logger::file_writer::close ( )

overridevirtual

Close the file.

Returns

common::VoidResult Success or error code

Implements kcenon::logger::log_writer_interface.

Definition at line 60 of file file_writer.cpp.

                                    {
    std::lock_guard<std::mutex> lock(mutex_);
    close_internal();
    return common::ok();
}

References close_internal(), mutex_, and kcenon::common::ok().

Here is the call graph for this function:

close_internal()

void kcenon::logger::file_writer::close_internal ( )

protected

Close the file (internal, caller must hold mutex)

Definition at line 114 of file file_writer.cpp.

                                 {
    // IMPORTANT: Caller must hold the mutex before calling this method
 
    if (is_open_) {
        if (file_stream_.is_open()) {
            file_stream_.flush();
            file_stream_.close();
        }
        is_open_ = false;
    }
}

References file_stream_, and is_open_.

Referenced by close(), and ~file_writer().

Here is the caller graph for this function:

flush()

common::VoidResult kcenon::logger::file_writer::flush ( )

overridevirtual

Flush file stream.

Returns

common::VoidResult Success or error code

Implements kcenon::logger::log_writer_interface.

Definition at line 48 of file file_writer.cpp.

                                    {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return utils::try_write_operation([&]() -> common::VoidResult {
        if (is_open_) {
            file_stream_.flush();
            return utils::check_stream_state(file_stream_, "flush");
        }
        return common::ok();
    }, logger_error_code::flush_timeout);
}

References kcenon::logger::utils::check_stream_state(), file_stream_, kcenon::logger::flush_timeout, is_open_, mutex_, kcenon::common::ok(), and kcenon::logger::utils::try_write_operation().

Here is the call graph for this function:

format_entry()

std::string kcenon::logger::file_writer::format_entry ( const log_entry & entry ) const

protected

Format a log entry using the current formatter.

Definition at line 70 of file file_writer.cpp.

                                                                {
    if (!formatter_) {
        // Fallback if formatter is somehow null
        return entry.message.to_string();
    }
    return formatter_->format(entry);
}

References formatter_, kcenon::logger::log_entry::message, and kcenon::logger::small_string< SSO_SIZE >::to_string().

Referenced by write(), and kcenon::logger::rotating_file_writer::write().

Here is the call graph for this function:

Here is the caller graph for this function:

get_file_size()

size_t kcenon::logger::file_writer::get_file_size ( ) const

inline

Get current file size.

Definition at line 104 of file file_writer.h.

{ return bytes_written_.load(); }

get_mutex()

std::mutex & kcenon::logger::file_writer::get_mutex ( ) const

inlineprotected

Access the writer mutex for extended operations.

Returns

Reference to the internal mutex

Definition at line 126 of file file_writer.h.

{ return mutex_; }

Referenced by kcenon::logger::rotating_file_writer::rotate(), and kcenon::logger::rotating_file_writer::write().

Here is the caller graph for this function:

get_name()

std::string kcenon::logger::file_writer::get_name ( ) const

inlineoverridevirtual

Get writer name.

Implements kcenon::logger::log_writer_interface.

Reimplemented in kcenon::logger::rotating_file_writer.

Examples

decorator_usage.cpp.

Definition at line 89 of file file_writer.h.

{ return "file"; }

Referenced by example_core_writers().

Here is the caller graph for this function:

is_healthy()

bool kcenon::logger::file_writer::is_healthy ( ) const

overridevirtual

Check if writer is healthy.

Implements kcenon::logger::log_writer_interface.

Definition at line 66 of file file_writer.cpp.

                                   {
    return is_open_ && file_stream_.good();
}

References file_stream_, and is_open_.

is_open()

bool kcenon::logger::file_writer::is_open ( ) const

inlinenodiscardoverridevirtual

Check if file is open.

Implements kcenon::logger::log_writer_interface.

Definition at line 94 of file file_writer.h.

{ return is_open_; }

open_internal()

common::VoidResult kcenon::logger::file_writer::open_internal ( )

protected

Open the file (internal, caller must hold mutex)

Definition at line 78 of file file_writer.cpp.

                                            {
    // IMPORTANT: Caller must hold the mutex before calling this method
 
    return utils::try_open_operation([&]() -> common::VoidResult {
        // Create directory if it doesn't exist
        std::filesystem::path file_path(filename_);
        std::filesystem::path dir = file_path.parent_path();
 
        auto dir_result = utils::ensure_directory_exists(dir);
        if (dir_result.is_err()) return dir_result;
 
        // Open file
        auto mode = append_mode_ ? std::ios::app : std::ios::trunc;
        file_stream_.open(filename_, std::ios::out | mode);
 
        // Check if file opened successfully
        auto check = utils::check_condition(
            file_stream_.is_open(),
            logger_error_code::file_open_failed,
            "Failed to open file: " + filename_
        );
        if (check.is_err()) return check;
 
        // Get current file size if appending
        if (append_mode_) {
            file_stream_.seekp(0, std::ios::end);
            bytes_written_ = file_stream_.tellp();
        } else {
            bytes_written_ = 0;
        }
 
        is_open_ = true;
        return common::ok();
    });
}

References append_mode_, bytes_written_, kcenon::logger::utils::check_condition(), kcenon::logger::utils::ensure_directory_exists(), kcenon::logger::file_open_failed, file_stream_, filename_, is_open_, kcenon::common::ok(), and kcenon::logger::utils::try_open_operation().

Referenced by file_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

file_writer & kcenon::logger::file_writer::operator= ( const file_writer & )

delete

operator=() [2/2]

file_writer & kcenon::logger::file_writer::operator= ( file_writer && )

delete

write()

common::VoidResult kcenon::logger::file_writer::write ( const log_entry & entry )

overridevirtual

Write a log entry to file.

Parameters

entry

The log entry to write

Returns

common::VoidResult Success or error code

Implements kcenon::logger::log_writer_interface.

Reimplemented in kcenon::logger::rotating_file_writer.

Definition at line 29 of file file_writer.cpp.

                                                          {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return utils::try_write_operation([&]() -> common::VoidResult {
        // Check precondition
        if (!is_open_) {
            return make_logger_void_result(logger_error_code::file_write_failed, "File is not open");
        }
 
        // Format and write
        std::string formatted = format_entry(entry);
        file_stream_ << formatted << '\n';
        bytes_written_.fetch_add(formatted.size() + 1);  // +1 for newline
 
        // Verify stream state
        return utils::check_stream_state(file_stream_, "write");
    });
}

References bytes_written_, kcenon::logger::utils::check_stream_state(), file_stream_, kcenon::logger::file_write_failed, format_entry(), is_open_, kcenon::logger::make_logger_void_result(), mutex_, and kcenon::logger::utils::try_write_operation().

Here is the call graph for this function:

Member Data Documentation

append_mode_

bool kcenon::logger::file_writer::append_mode_

protected

Definition at line 130 of file file_writer.h.

Referenced by open_internal(), and kcenon::logger::rotating_file_writer::perform_rotation().

bytes_written_

std::atomic<size_t> kcenon::logger::file_writer::bytes_written_ {0}

protected

Definition at line 134 of file file_writer.h.

{0};

Referenced by kcenon::logger::rotating_file_writer::get_file_size(), open_internal(), kcenon::logger::rotating_file_writer::perform_rotation(), write(), and kcenon::logger::rotating_file_writer::write().

file_stream_

std::ofstream kcenon::logger::file_writer::file_stream_

protected

Definition at line 132 of file file_writer.h.

Referenced by close_internal(), flush(), kcenon::logger::rotating_file_writer::get_file_size(), is_healthy(), open_internal(), kcenon::logger::rotating_file_writer::perform_rotation(), write(), and kcenon::logger::rotating_file_writer::write().

filename_

std::string kcenon::logger::file_writer::filename_

protected

Definition at line 129 of file file_writer.h.

Referenced by kcenon::logger::rotating_file_writer::generate_rotated_filename(), kcenon::logger::rotating_file_writer::get_backup_files(), kcenon::logger::rotating_file_writer::get_file_size(), open_internal(), and kcenon::logger::rotating_file_writer::perform_rotation().

formatter_

std::unique_ptr<log_formatter_interface> kcenon::logger::file_writer::formatter_

protected

Definition at line 136 of file file_writer.h.

Referenced by format_entry().

is_open_

std::atomic<bool> kcenon::logger::file_writer::is_open_ {false}

protected

Definition at line 133 of file file_writer.h.

{false};

Referenced by close_internal(), flush(), is_healthy(), open_internal(), and write().

mutex_

std::mutex kcenon::logger::file_writer::mutex_

mutableprotected

Definition at line 137 of file file_writer.h.

Referenced by close(), file_writer(), flush(), write(), and ~file_writer().

---

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

• include/kcenon/logger/writers/file_writer.h
• src/impl/writers/file_writer.cpp