records.hpp

Go to the documentation of this file.

#pragma once
 
#include "run_result.hpp"
#include "task.hpp"
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <list>
#include <map>
#include <string>
#include <string_view>
#include <vector>
 
namespace joque
{
 
enum class run_status : uint8_t
{
        OK,
        SKIP,
        DEPF,
        FAIL,
};
 
std::string_view to_sv( const run_status& s );
 
using tp = std::chrono::time_point< std::chrono::system_clock >;
 
struct run_record
{
        std::reference_wrapper< const task > t;
 
        std::string name;
 
        run_status status = run_status::OK;
 
        int retcode = 0;
 
        tp start = std::chrono::system_clock::now();
 
        tp end = std::chrono::system_clock::now();
 
        std::list< output_chunk > output;
};
 
void map( std::convertible_to< run_record > auto& rec, auto&& f )
{
        f( "t", rec.t );
        f( "name", rec.name );
        f( "status", rec.status );
        f( "retcode", rec.retcode );
        f( "start", rec.start );
        f( "end", rec.end );
        f( "output", rec.output );
}
 
struct exec_record
{
        std::map< run_status, std::size_t > stats{
            { run_status::OK, 0 },
            { run_status::SKIP, 0 },
            { run_status::DEPF, 0 },
            { run_status::FAIL, 0 },
        };
        std::size_t total_count = 0;
        std::vector< run_record > runs;
};
 
std::chrono::seconds runtime_sum( const exec_record& erec );
 
void map( std::convertible_to< exec_record > auto& rec, auto&& f )
{
        for ( auto&& [k, v] : rec.stats )
                f( to_sv( k ), v );
        f( "total_count", rec.total_count );
        f( "runs", rec.runs );
}
 
}  // namespace joque