task.hpp

//SPDX-License-Identifier: LicenseRef-Apache-License-2.0
//Author: Blayne Dennis
 
#ifndef __SIMPLE_THREADING_TASK__
#define __SIMPLE_THREADING_TASK__
 
#include <functional>
 
#include "utility.hpp"
#include "context.hpp"
#include "data.hpp"
 
namespace st {
namespace detail {
namespace task {
 
struct context {
    context() : evaluate([&]() -> data& { return m_result; }) { }
 
    template <typename Callable, typename... As>
    context(Callable&& cb, As&&... as) { 
        using isv = typename std::is_void<detail::function_return_type<Callable,As...>>;
        evaluate = create_function(
                std::integral_constant<bool,isv::value>(),
                std::forward<Callable>(cb),
                std::forward<As>(as)...);
    }
 
    // handle case where Callable returns void
    template <typename Callable, typename... As>
    std::function<data&()> 
    create_function(std::true_type, Callable&& cb, As&&... as) {
        return [=]() mutable -> data& {
            if(!(this->m_flag)) {
                this->m_flag = true;
                cb(std::forward<As>(as)...);
            }
 
            return this->m_result; // return empty data
        };
    }
 
    // handle case where Callable returns some value
    template <typename Callable, typename... As>
    std::function<data&()> 
    create_function(std::false_type, Callable&& cb, As&&... as) {
        return [=]() mutable -> data& {
            if(!(this->m_flag)) {
                this->m_flag = true;
                typedef detail::function_return_type<Callable,As...> R;
                this->m_result = data::make<R>(cb(std::forward<As>(as)...));
            }
 
            return this->m_result;
        };
    }
 
 
    bool m_flag = false;
    data m_result;
    std::function<data&()> evaluate;
};
 
}
}
 
struct task : public st::shared_context<task, detail::task::context> {
    inline virtual ~task() { }
 
    template <typename... As>
    static task make(As&&... as) {
        task t;
        t.ctx(std::make_shared<detail::task::context>(std::forward<As>(as)...));
        return t;
    }
 
    inline data& operator()() {
        if(!ctx()) {
            ctx(std::make_shared<detail::task::context>());
        }
 
        return ctx()->evaluate();
    }
};
 
}
 
#endif