environment.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
 
#ifndef YARP_CONF_ENVIRONMENT_H
#define YARP_CONF_ENVIRONMENT_H
 
#include <yarp/conf/api.h>
#include <yarp/conf/system.h>
#include <yarp/conf/numeric.h>
#include <yarp/conf/string.h>
 
#include <cstdlib>
#include <numeric>
#include <regex>
#include <string>
#include <type_traits>
#include <vector>
 
namespace yarp {
namespace conf {
namespace environment {
 
#if defined(_WIN32)
static constexpr char path_separator = ';';
#else
static constexpr char path_separator = ':';
#endif
 
 
template <typename ContainerT = std::vector<std::string>>
inline ContainerT split_path(const typename ContainerT::value_type& s)
{
    return yarp::conf::string::split<ContainerT>(s, typename ContainerT::value_type::value_type{yarp::conf::environment::path_separator});
}
 
template <typename ContainerT = std::vector<std::string>>
inline typename ContainerT::value_type join_path(const ContainerT& v)
{
    return yarp::conf::string::join<ContainerT>(v.begin(), v.end(), typename ContainerT::value_type::value_type{yarp::conf::environment::path_separator});
}
 
inline std::string get_string(const std::string& key, bool* found = nullptr)
{
    const char* result = std::getenv(key.c_str());
    if (found != nullptr) {
        *found = (result != nullptr);
    }
    if (result == nullptr) {
        return {};
    }
    return std::string(result);
}
 
inline std::string get_string(const std::string& key, const std::string& defaultValue)
{
    const char* result = std::getenv(key.c_str());
    return result ? std::string{result} : defaultValue;
}
 
inline std::string get_string(const std::string& key, const std::string& altKey, const std::string& altDefaultValue, const std::string& altAppend = {})
{
    bool found;
    auto ret = get_string(key, &found);
    return (found ? ret : get_string(altKey, altDefaultValue) + altAppend);
}
 
inline std::vector<std::string> get_path(const std::string& key, bool* found = nullptr)
{
    return split_path(get_string(key, found));
}
 
inline std::vector<std::string> get_path(const std::string& key, const std::string& defaultValue)
{
    return split_path(get_string(key, defaultValue));
}
 
inline std::vector<std::string> get_path(const std::string& key, const std::string& altKey, const std::string& altDefaultValue, const std::string& altAppend = {})
{
    bool found;
    std::vector<std::string> path = get_path(key, &found);
    if (!found) {
        path = get_path(altKey, altDefaultValue);
        if (!altAppend.empty()) {
            for (auto& dir : path) {
                dir.append(altAppend);
            }
        }
    }
    return path;
}
 
inline bool get_bool(const std::string& key, bool defaultValue = false)
{
    const char *strvalue = std::getenv(key.c_str());
    if(!strvalue) {
        return defaultValue;
    }
    return yarp::conf::numeric::from_string<bool>(strvalue, defaultValue);
}
 
template <typename T>
inline T get_numeric(const std::string& key, T defaultValue = static_cast<T>(0))
{
    const char *strvalue = std::getenv(key.c_str());
    if (!strvalue) {
        return defaultValue;
    }
    return yarp::conf::numeric::from_string<T>(strvalue, defaultValue);
}
 
inline bool set_string(const std::string& key, const std::string& value)
{
#if defined(_MSC_VER)
    auto ret = _putenv_s(key.c_str(), value.c_str());
#else
    auto ret = ::setenv(key.c_str(), value.c_str(), 1);
#endif
    return (ret == 0);
}
 
inline bool set_path(const std::string& key, const std::vector<std::string>& value)
{
    return set_string(key, join_path(value));
}
 
inline bool set_bool(const std::string& key, bool value)
{
    // Boolean environment variables are usually set as "1" or "0", and not
    // as "true" or "false", therefore `to_string` is not used here.
    return set_string(key, value ? "1" : "0");
}
 
template <typename T>
inline bool set_numeric(const std::string& key, bool value)
{
    return set_string(key, yarp::conf::numeric::to_string(value));
}
 
inline bool unset(const std::string& key)
{
#if defined(_MSC_VER)
    auto ret = _putenv_s(key.c_str(), "");
#else
    auto ret = ::unsetenv(key.c_str());
#endif
    return (ret == 0);
}
 
inline bool is_set(const std::string& key)
{
    return std::getenv(key.c_str()) ? true : false;
}
 
 
#ifndef YARP_NO_DEPRECATED // Since YARP 3.5
YARP_DEPRECATED_MSG("Use yarp::conf::environment::get_string() instead")
inline std::string
getEnvironment(const char* key, bool* found = nullptr)
{
    return get_string(key, found);
}
 
YARP_DEPRECATED_MSG("Use yarp::conf::environment::set_string() instead")
inline void setEnvironment(const std::string& key, const std::string& value)
{
    set_string(key, value);
}
 
YARP_DEPRECATED_MSG("Use yarp::conf::environment::unset() instead")
inline void unsetEnvironment(const std::string& key)
{
    unset(key);
}
 
 
#endif // YARP_NO_DEPRECATED
 
} // namespace environment
} // namespace conf
} // namespace yarp
 
#endif // YARP_CONF_ENVIRONMENT_H