TomlProcessingFunctions.hpp

Go to the documentation of this file.

/*
Copyright (c) 2017-2026,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Energy
Innovation LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "../core/helicsTime.hpp"
#ifdef __GNUC__
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wshadow"
#endif
#include <string_view>
#define TOML11_USING_STRING_VIEW 1
#include "toml.hpp"
#ifdef __GNUC__
#    pragma GCC diagnostic pop
#endif
 
#include <functional>
#include <string>
 
namespace helics::fileops {
toml::value loadToml(const std::string& tomlString);
bool hasTomlExtension(std::string_view tomlString);
bool looksLikeConfigToml(std::string_view tomlString);
toml::value loadTomlStr(const std::string& tomlString);
 
std::string tomlAsString(const toml::value& element);
 
helics::Time loadTomlTime(const toml::value& timeElement,
                          time_units defaultUnits = time_units::sec);
 
std::string getName(const toml::value& element);
 
inline std::string
    getOrDefault(const toml::value& element, const std::string& key, std::string_view defVal)
{
    if (element.contains(key)) {
        return tomlAsString(element.at(key));
    }
    return std::string(defVal);
}
inline double getOrDefault(const toml::value& element, const std::string& key, double defVal)
{
    return toml::find_or<double>(element, key, defVal);
}
 
inline bool getOrDefault(const toml::value& element, const std::string& key, bool defVal)
{
    return toml::find_or<bool>(element, key, defVal);
}
 
inline int64_t getOrDefault(const toml::value& element, const std::string& key, int64_t defVal)
{
    return toml::find_or<int64_t>(element, key, defVal);
}
 
inline bool callIfMember(const toml::value& element,
                         const std::string& key,
                         const std::function<void(const std::string&)>& call)
{
    const std::string empty;
    auto& val = toml::find_or<std::string>(element, key, empty);
    if (!val.empty()) {
        call(val);
        return true;
    }
    return false;
}
 
inline bool callIfMember(const toml::value& element,
                         const std::string& key,
                         const std::function<void(const std::string&, helics::Time)>& call)
{
    toml::value uval;
    auto val = toml::find_or(element, key, uval);
 
    if (!val.is_empty()) {
        call(key, loadTomlTime(val));
        return true;
    }
    return false;
}
 
template<class X>
inline bool callIfMember(const toml::value& element,
                         const std::string& key,
                         const std::function<void(const std::string&, X)>& call)
{
    toml::value uval;
    auto val = toml::find_or(element, key, uval);
    if (!val.is_empty()) {
        call(key, toml::get<X>(val));
        return true;
    }
    return false;
}
 
inline void
    replaceIfMember(const toml::value& element, const std::string& key, helics::Time& timeVal)
{
    toml::value uval;
    auto val = toml::find_or(element, key, uval);
 
    if (!val.is_empty()) {
        timeVal = loadTomlTime(val);
    }
}
 
inline void replaceIfMember(const toml::value& element, const std::string& key, std::string& loc)
{
    toml::value uval;
    auto val = toml::find_or(element, key, uval);
 
    if (!val.is_empty()) {
        loc = tomlAsString(val);
    }
}
 
template<class X>
inline void replaceIfMember(const toml::value& element, const std::string& key, X& loc)
{
    toml::value uval;
    auto val = toml::find_or(element, key, uval);
 
    if (!val.is_empty()) {
        loc = toml::get<X>(val);
    }
}
 
inline bool isMember(const toml::value& element, const std::string& key)
{
    toml::value uval;
    auto val = toml::find_or(element, key, uval);
 
    return (!val.is_empty());
}
 
}  // namespace helics::fileops