pool_builder.h

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.
 
#pragma once
 
#include "forward_declarations.h"
#include "config.h"
#include "job_types.h"
#include <memory>
#include <vector>
#include <string>
 
namespace kcenon::thread {
    
    template<detail::JobType job_type = job_types>
    class typed_thread_pool_builder {
    public:
        typed_thread_pool_builder() = default;
        
        typed_thread_pool_builder& with_title(const std::string& title) {
            title_ = title;
            return *this;
        }
        
        typed_thread_pool_builder& with_worker_count(size_t count) {
            worker_count_ = count;
            return *this;
        }
        
        typed_thread_pool_builder& with_queue_size(size_t size) {
            queue_size_ = size;
            return *this;
        }
        
        typed_thread_pool_builder& with_job_types(const std::vector<job_type>& types) {
            job_types_ = types;
            return *this;
        }
        
        typed_thread_pool_builder& with_time_tagging(bool enable) {
            use_time_tag_ = enable;
            return *this;
        }
        
        typed_thread_pool_builder& with_auto_start(bool auto_start) {
            auto_start_ = auto_start;
            return *this;
        }
        
        [[nodiscard]] bool validate() const {
            return worker_count_ >= config::min_workers && 
                   worker_count_ <= config::max_workers &&
                   queue_size_ > 0 &&
                   !title_.empty();
        }
        
        [[nodiscard]] std::shared_ptr<typed_thread_pool_t<job_type>> build() {
            if (!validate()) {
                throw std::invalid_argument("Invalid thread pool configuration");
            }
            
            auto pool = std::make_shared<typed_thread_pool_t<job_type>>(title_);
            
            // Create workers with specified job types
            for (size_t i = 0; i < worker_count_; ++i) {
                auto worker = std::make_unique<typed_thread_worker_t<job_type>>(
                    job_types_, use_time_tag_
                );
                pool->enqueue(std::move(worker));
            }
            
            if (auto_start_) {
                auto result = pool->start();
                if (result.has_error()) {
                    throw std::runtime_error("Failed to start thread pool: " + 
                                           result.get_error().message());
                }
            }
            
            return pool;
        }
        
        typed_thread_pool_builder& reset() {
            title_ = "typed_thread_pool";
            worker_count_ = config::default_worker_count;
            queue_size_ = config::default_queue_size;
            job_types_.clear();
            use_time_tag_ = true;
            auto_start_ = false;
            return *this;
        }
        
    private:
        std::string title_ = "typed_thread_pool";
        size_t worker_count_ = config::default_worker_count;
        size_t queue_size_ = config::default_queue_size;
        std::vector<job_type> job_types_;
        bool use_time_tag_ = true;
        bool auto_start_ = false;
    };
    
    template<detail::JobType job_type = job_types>
    [[nodiscard]] typed_thread_pool_builder<job_type> create_pool_builder() {
        return typed_thread_pool_builder<job_type>{};
    }
    
} // namespace kcenon::thread