task.hpp

Go to the documentation of this file.

#pragma once
 
#include "job.hpp"
 
#include <functional>
#include <map>
#include <memory>
#include <span>
#include <string>
#include <type_traits>
#include <vector>
 
namespace joque
{
 
struct resource
{
        std::string name;
};
 
template < typename T >
using ref_vec = std::vector< std::reference_wrapper< const T > >;
 
struct task
{
        job_ptr job;
 
        ref_vec< task > depends_on = {};
 
        ref_vec< task > run_after = {};
 
        ref_vec< task > invalidated_by = {};
 
        ref_vec< resource > resources = {};
 
        bool hidden = false;
};
 
struct task_set
{
        std::map< std::string, task > tasks;
        std::map< std::string, task_set > sets;
};
 
template < typename T, typename Fun >
requires( std::same_as< std::remove_cvref_t< T >, task_set > )
void for_each_task( T& ts, Fun&& f );
 
void for_each_add_dep( task_set& ts, const task& dep );
 
void add_dep_to_each( task& t, const task_set& ts );
 
void run_each_after( task_set& ts, const task& t );
 
void run_after_all_of( task& t, const task_set& ts );
 
void invalidated_by_all_of( task& t, const task_set& ts );
 
template < typename T, typename Fun >
void for_each_task_impl( T& ts, Fun&& f, const std::string& prefix )
{
        for ( auto& [name, t] : ts.tasks )
                f( ( prefix + "/" ).append( name ), t );
        for ( auto& [name, s] : ts.sets )
                for_each_task_impl( s, f, ( prefix + "/" ).append( name ) );
}
 
template < typename T, typename Fun >
requires( std::same_as< std::remove_cvref_t< T >, task_set > )
void for_each_task( T& ts, Fun&& f )
{
        for_each_task_impl( ts, f, "/" );
}
 
}  // namespace joque