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"
#include "G4SystemOfUnits.hh"
#include "G4UnitsTable.hh"
 
namespace gemc_units {
    inline constexpr G4double milligray = 1.e-3 * gray;
    inline constexpr G4double microgray = 1.e-6 * gray;
    inline constexpr G4double nanogray = 1.e-9 * gray;
    inline constexpr G4double picogray = 1.e-12 * gray;
}
 
 

 
namespace gutilities {
using std::string;
using std::vector;
using std::map;


std::string removeLeadingAndTrailingSpacesFromString(const std::string& input);

std::string_view removeLeadingAndTrailingSpacesFromString(const std::string_view input);

std::string removeAllSpacesFromString(const std::string& str);

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);



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);

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);



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);



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 makeG4Colour(std::string_view code, double opacity);

};
 
 
#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() {
    const auto exe_dir = executable_path().parent_path();
 
    std::filesystem::path root;
 
    // Case 1: executable is directly in the build directory (legacy build-tree layout)
    if (exe_dir.filename() == "build") {
        root = exe_dir.parent_path();
    }
    // Case 2: executable is in a bin/ subdirectory — installed or build/bin/
    else if (exe_dir.filename() == "bin") {
        root = exe_dir.parent_path();
        if (std::filesystem::exists(root / "build.ninja")) {
            // Running from build/bin/: step up one more level to match the legacy build-tree root
            root = root.parent_path();
        } else if (!std::filesystem::exists(root / "lib")) {
            throw std::runtime_error(
                "Cannot locate directory <lib> under " + root.string() +
                ". Check installation layout."
            );
        }
    }
 
    return root;
}
 

bool is_unset(std::string_view s);

inline std::string success_or_fail(bool condition) { return condition ? "success" : "fail"; }

void apply_uimanager_commands(const std::string& commands);
}