string.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#pragma once
 
#include <boost/lexical_cast.hpp>
#include <range/v3/view/transform.hpp>
 
#include <algorithm>
#include <locale>
#include <experimental/filesystem>
#include <set>
#include <sstream>
#include <string>
 
namespace hipipe::utility {
 
template<typename T>
T string_to(const std::string& str)
{
    try {
        return boost::lexical_cast<T>(str);
    } catch(const boost::bad_lexical_cast &) {
        throw std::ios_base::failure{std::string{"Failed to read type <"} + typeid(T).name() +
                                     "> from string \"" + str + "\"."};
    }
}
 
template<>
inline std::string string_to<std::string>(const std::string& str)
{
    return str;
}
 
template<>
inline std::experimental::filesystem::path
string_to<std::experimental::filesystem::path>(const std::string& str)
{
    return str;
}
 
namespace detail
{
    const std::set<std::string> true_set =
      {"true ", "True ", "TRUE ", "1", "y", "Y", "yes", "Yes", "YES", "on ", "On ", "ON"};
    const std::set<std::string> false_set =
      {"false", "False", "FALSE", "0", "n", "N", "no ", "No ", "NO ", "off", "Off", "OFF"};
}
 
template<>
inline bool string_to<bool>(const std::string& str)
{
    if (detail::true_set.count(str)) return true;
    if (detail::false_set.count(str)) return false;
    throw std::ios_base::failure{"Failed to convert string \"" + str + "\" to bool."};
}
 
template<typename T>
std::string to_string(const T& value)
{
    try {
        return boost::lexical_cast<std::string>(value);
    } catch(const boost::bad_lexical_cast &) {
        throw std::ios_base::failure{std::string{"Failed to read string from type <"}
                                     + typeid(T).name() + ">."};
    }
}
 
inline std::string to_string(const std::experimental::filesystem::path& path)
{
    return path.string();
}
 
inline std::string to_string(const std::string& str)
{
    return str;
}
 
inline std::string to_string(const char* const& str)
{
    return str;
}
 
inline std::string to_string(const bool& b)
{
    return b ? "true" : "false";
}
 
}  // namespace hipipe