MRProgressCallback.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshFwd.h"
 
#include <array>
#include <cassert>
#include <cmath>
#include <tuple>
#include <utility>
 
namespace MR
{
 

inline bool reportProgress( ProgressCallback cb, float v )
{
    if ( cb )
        return cb( v );
    return true;
}

inline bool reportProgress( ProgressCallback cb, float v, size_t counter, int divider )
{
    if ( cb && ( counter % divider == 0 ) )
        return cb( v );
    return true;
}

template<typename F>
inline bool reportProgress( ProgressCallback cb, F && f )
{
    if ( cb )
        return cb( f() );
    return true;
}

template<typename F>
inline bool reportProgress( ProgressCallback cb, F && f, size_t counter, int divider )
{
    if ( cb && ( counter % divider == 0 ) )
        return cb( f() );
    return true;
}

inline ProgressCallback subprogress( ProgressCallback cb, float from, float to )
{
    assert( from <= to );
    ProgressCallback res;
    if ( cb )
        res = [cb = std::move( cb ), from, to]( float v ) { return cb( std::lerp( from, to, v ) ); };
    return res;
}

template<typename F>
inline ProgressCallback subprogress( ProgressCallback cb, F && f )
{
    ProgressCallback res;
    if ( cb )
        res = [cb = std::move( cb ), f = std::forward<F>( f )]( float v ) { return cb( f( v ) ); };
    return res;
}

inline ProgressCallback subprogress( ProgressCallback cb, size_t index, size_t count )
{
    assert( index < count );
    if ( cb )
        return [cb = std::move( cb ), index, count] ( float v ) { return cb( ( (float)index + v ) / (float)count ); };
    else
        return {};
}

template <typename ...Ts>
auto splitProgress( const ProgressCallback& cb, Ts ... thresholds )
{
    constexpr size_t n = sizeof...( Ts );
    static_assert( n > 0, "at least one threshold is required" );
    const std::array<float, n + 2> bounds{ 0.0f, float( thresholds )..., 1.0f };
    return [&]<size_t ...I>( std::index_sequence<I...> )
    {
        return std::tuple{ subprogress( cb, bounds[I], bounds[I + 1] )... };
    }( std::make_index_sequence<n + 1>{} );
}
 
}