process.hpp

Go to the documentation of this file.

#pragma once
 
#include "out.hpp"
#include "run_result.hpp"
#include "traits.hpp"
 
#include <concepts>
#include <filesystem>
#include <optional>
#include <string>
#include <type_traits>
#include <vector>
 
namespace joque
{
 
struct process
{
        std::vector< std::string > cmd;
        std::vector< std::filesystem::path > input;
        std::vector< std::filesystem::path > output;
 
        std::optional< std::filesystem::path > retcode_file;  // TODO: write
                                                              // tests for this
 
        template < typename... Args >
        [[nodiscard]] static process derive( Args&&... args );
 
        process add_output( std::filesystem::path p ) &&;
 
        process add_input( std::filesystem::path p ) &&;
 
        process set_retcode_file( std::filesystem::path p ) &&;
};
 
template <>
struct job_traits< process >
{
        [[nodiscard]] static inval_result is_invalidated( const process& p );
 
        [[nodiscard]] static run_result run( const task&, const process& p );
};
 
template < typename... Args >
process process::derive( Args&&... args )
{
        process res;
 
        auto f = [&]< typename T >( T&& thing ) {
                if constexpr ( std::derived_from< std::decay_t< T >, out_tag > ) {
                        res.cmd.push_back( thing.p );
                        res.output.push_back( thing.p );
                } else if constexpr ( std::same_as< std::decay_t< T >, std::filesystem::path > ) {
                        res.cmd.push_back( thing );
                        res.input.push_back( thing );
                } else {
                        res.cmd.push_back( thing );
                }
        };
        ( f( args ), ... );
        return res;
}
 
}  // namespace joque