gutilities.h

Go to the documentation of this file.

#pragma once
 
// c++
#include <vector>
#include <string>
#include <map>
#include <string_view>
#include <optional>
 
// geant4
#include "G4Colour.hh"
 
namespace gutilities {
 
using std::string;
using std::vector;
using std::map;
 
std::string removeLeadingAndTrailingSpacesFromString(const std::string& input);
 
std::string removeAllSpacesFromString(const std::string& str);
 
std::string getFileFromPath(const std::string& path);
 
std::string getDirFromPath(const std::string& path);
 
std::optional<std::string> searchForFileInLocations(
    const std::vector<std::string>& locations,
    std::string_view                filename);
 
std::vector<std::string> getStringVectorFromString(const std::string& input);
 
std::string replaceCharInStringWithChars(const std::string& input, const std::string& toReplace,
                                         const std::string& replacement);
 
 
string replaceAllStringsWithString(const string& source, const string& from, const string& to);
 
string fillDigits(const string& word, const string& c, int ndigits);
 
double getG4Number(const string& v, bool warnIfNotUnit = false);
 
double getG4Number(double input, const string& unit);
 
vector<double> getG4NumbersFromStringVector(const vector<string>& vstring, bool warnIfNotUnit = false);
 
vector<double> getG4NumbersFromString(const string& vstring, bool warnIfNotUnit = false);
 
string parseFileAndRemoveComments(const string& filename, const string& commentChars = "#", int verbosity = 0);
 
 
string retrieveStringBetweenChars(const string& input, const string& firstDelimiter, const string& secondDelimiter);
 
 
vector<string> getStringVectorFromStringWithDelimiter(const string& input, const string& x);
 
bool directoryExists(const std::string& path);
 
 
string searchForDirInLocations(const string& dirName, const vector<string>& possibleLocations);
 
 
bool hasExtension(const string& filename, const vector<string>& extensions);
 
vector<string> getListOfFilesInDirectory(const string& dirName, const vector<string>& extensions);
 
string convertToLowercase(const string& str);
 
template <class KEY, class VALUE>
vector<KEY> getKeys(const map<KEY, VALUE>& map);
 
enum randomModel {
    uniform,  
    gaussian, 
    cosine,   
    sphere    
};
 
randomModel stringToRandomModel(const std::string& str);
 
inline constexpr const char* to_string(randomModel m) noexcept {
    switch (m) {
    case uniform: return "uniform";
    case gaussian: return "gaussian";
    case cosine: return "cosine";
    case sphere: return "sphere";
    }
    return "<unknown>";
}
 
G4Colour makeColour(std::string_view code);
 
};
 
 
#include <filesystem>
 
#if defined(__APPLE__)
#include <mach-o/dyld.h>   // _NSGetExecutablePath
#elif defined(__linux__)
#include <unistd.h>        // readlink
#include <limits.h>
#elif defined(_WIN32)
#include <windows.h>
#include <vector>
#else
#error "Unsupported platform"
#endif
 
namespace gutilities {
inline std::filesystem::path executable_path() {
#if defined(__APPLE__)
    char     buf[PATH_MAX];
    uint32_t sz = sizeof(buf);
    if (_NSGetExecutablePath(buf, &sz) != 0) { // buffer too small
        std::string big(sz, '\0');
        if (_NSGetExecutablePath(big.data(), &sz) != 0)
            throw std::runtime_error("_NSGetExecutablePath failed");
        return std::filesystem::canonical(big);
    }
    return std::filesystem::canonical(buf);
 
#elif defined(__linux__)
    char    buf[PATH_MAX];
    ssize_t len = ::readlink("/proc/self/exe", buf, sizeof(buf) - 1);
    if (len == -1)
        throw std::runtime_error("readlink(/proc/self/exe) failed");
    buf[len] = '\0';
    return std::filesystem::canonical(buf);
 
#elif defined(_WIN32)
    std::wstring buf(MAX_PATH, L'\0');
    DWORD        len = ::GetModuleFileNameW(nullptr, buf.data(), buf.size());
    if (len == 0)
        throw std::runtime_error("GetModuleFileNameW failed");
    // If the path is longer than MAX_PATH the buffer is truncated;
    // do a second call with the returned length to get the full path.
    if (len == buf.size()) {
        buf.resize(len * 2);
        len = ::GetModuleFileNameW(nullptr, buf.data(), buf.size());
    }
    buf.resize(len);
    return std::filesystem::canonical(std::filesystem::path(buf));
#endif
}
 
inline std::filesystem::path gemc_root() {
    auto exe_dir   = executable_path().parent_path(); // where the executable is installed
    auto gemc_root = exe_dir.parent_path();           // one dir up. The danger here is where this is a
 
    // Sanity‑check api dir
    if (!std::filesystem::exists(gemc_root / "api"))
        throw std::runtime_error("Cannot locate directory >api< check directory layout");
 
    return gemc_root;
}
 
inline std::string success_or_fail(bool condition) { return condition ? "success" : "fail"; }
 
}