ecs/include/ecs/core/utils/thread_pool/task_queue.h

#pragma once

#include <sstream> // TODO debug!
#include <queue>
#include <ecs/config.h>
#include <moodycamel/concurrentqueue.h>

#include "../fixed_function.h"

namespace ecs {
namespace core {
namespace utils {

    /**
     * Functor to execute as task inside the thread pool. The functor can have a max size of 128 bytes!
     */
    using task = fixed_function<void(size_t thread_id), 128>;

    /**
     * normal task queue
     */
    using task_queue = std::queue<task>;

    /**
     * none blocking concurrent queue to store thread pool tasks in
     */
    struct concurrent_task_queue
    {
    private:
        using inner_queue_type = moodycamel::ConcurrentQueue<task>;

    private:
        std::atomic<ssize_t>    _count;
        inner_queue_type        _inner_queue;

    public:
        /**
         * constructor
         */
        concurrent_task_queue();

        /**
         * check if the task queue is empty
         *
         * @retval TRUE if the queue is empty
         * @retval FALSE if the queue contains at least one element
         */
        inline bool empty() const;

        /**
         * push a new element to the queue
         *
         * @param t     task to push to queue
         */
        void push(task&& t);

        /**
         * try to get dequeue a task from the queue
         *
         * @param t     dequeued task
         *
         * @retval      TRUE if an task was dequeued
         * @retval      FALSE if the queue is empty
         */
        bool pop(task& t);
    };

} } }