System.hpp

#pragma once
 
#include "system/Config.hpp"
#include "Common.hpp"
 
#include <thread>
 
class System {
public:
    enum class Picker {
        Load,     
        Directory, 
        Save       
    };
 
    static bool showPicker(Picker mode, const std::string & startDir, std::string & outPath, const std::string & extensions = "");
 
    static bool createDirectory(const std::string & directory);
 
    static void ping();
    
    static double time();
 
    static std::string timestamp();
 
    static uint64_t hash64(const void* data, size_t size);
 
    static uint32_t hash32(const void* data, size_t size);
 
    template<typename ThreadFunc>
    static void forParallel(size_t low, size_t high, ThreadFunc func) {
        // Make sure the loop is increasing.
        if(high < low) {
            const size_t temp = low;
            low               = high;
            high              = temp;
        }
        // Prepare the threads pool.
        // Always leave one thread free.
        const size_t availableThreadsCount = std::max(int(std::thread::hardware_concurrency())-1, 1);
        const size_t count = std::min(size_t(availableThreadsCount), high - low);
        std::vector<std::thread> threads;
        threads.reserve(count);
 
        // Compute the span of each thread.
        const size_t span = std::max(size_t(1), (high - low) / count);
        // Helper to execute the function passed on a subset of the total interval.
        auto launchThread = [&func](size_t a, size_t b) {
            for(size_t i = a; i < b; ++i) {
                func(i);
            }
        };
 
        for(size_t tid = 0; tid < count; ++tid) {
            // For each thread, call the same lambda with different bounds as arguments.
            const size_t threadLow  = tid * span;
            const size_t threadHigh = tid == (count-1) ? high : ((tid + 1) * span);
            threads.emplace_back(launchThread, threadLow, threadHigh);
        }
        // Wait for all threads to finish.
        std::for_each(threads.begin(), threads.end(), [](std::thread & x) { x.join(); });
    }
 
    #ifdef _WIN32
 
    static wchar_t * widen(const std::string & str);
    
    static std::string narrow(wchar_t * str);
 
    #else
 
    static const char * widen(const std::string & str);
    
    static std::string narrow(char * str);
 
    #endif
 
};