callback_job.cpp

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include <kcenon/thread/core/callback_job.h>
 
namespace kcenon::thread
{
    callback_job::callback_job(const std::function<std::optional<std::string>(void)>& callback,
                               const std::string& name)
        : job(name), callback_([callback](void) -> common::VoidResult {
            // Call the original callback and convert error format
            auto result = callback();
            if (result.has_value()) {
                // Error occurred: convert string to error object
                return common::error_info{static_cast<int>(error_code::job_execution_failed), result.value(), "thread_system"};
            }
            // Success: return empty result
            return common::ok();
        }), data_callback_(nullptr)
    {
    }
 
    callback_job::callback_job(
        const std::function<common::VoidResult(void)>& callback,
        const std::string& name)
        : job(name), callback_(callback), data_callback_(nullptr)
    {
    }
 
    callback_job::callback_job(
        const std::function<std::optional<std::string>(const std::vector<uint8_t>&)>& data_callback,
        const std::vector<uint8_t>& data, const std::string& name)
        : job(data, name), callback_(nullptr), data_callback_([data_callback](const std::vector<uint8_t>& callback_data) -> common::VoidResult {
            // Call the original data callback with provided data
            auto result = data_callback(callback_data);
            if (result.has_value()) {
                // Error occurred: convert string to error object
                return common::error_info{static_cast<int>(error_code::job_execution_failed), result.value(), "thread_system"};
            }
            // Success: return empty result
            return common::ok();
        })
    {
    }
 
    callback_job::callback_job(
        const std::function<common::VoidResult(const std::vector<uint8_t>&)>& data_callback,
        const std::vector<uint8_t>& data, const std::string& name)
        : job(data, name), callback_(nullptr), data_callback_(data_callback)
    {
    }
 
    callback_job::~callback_job(void) {}
 
    auto callback_job::do_work(void) -> common::VoidResult
    {
        // Priority 1: Data callback with stored binary data
        if (data_callback_)
        {
            // Execute data-processing callback with job's stored data
            return data_callback_(data_);
        }
        // Priority 2: Standard parameterless callback
        else if (callback_)
        {
            // Execute standard callback function
            return callback_();
        }
        // Priority 3: Fallback to base class implementation
        else
        {
            // No callbacks set - delegate to base job class
            // This typically returns a "not implemented" error
            return job::do_work();
        }
    }
} // namespace kcenon::thread