cast.hpp

Go to the documentation of this file.

//
// Copyright 2014-2015 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/exception.hpp>
#include <type_traits>
#include <complex>
#include <cstdint>
#include <iomanip>
#include <ios>
#include <limits>
#include <locale>
#include <sstream>
#include <string>
 
namespace uhd { namespace cast {
template <typename T>
inline T hexstr_cast(const std::string& in)
{
    T x;
    std::stringstream ss;
    ss << std::hex << in;
    ss >> x;
    return x;
}

template <typename T>
inline T fromstr_cast(const std::string& in)
{
    T x;
    std::istringstream is(in);
    is >> std::setbase(0) >> x;
    return x;
}

template <typename data_t>
data_t from_str(const std::string& val)
{
    if constexpr (
        (std::is_same_v<data_t,
             size_t> || std::is_same_v<data_t, unsigned long> || std::is_same_v<data_t, unsigned long long>)&&!std::
            is_same_v<data_t, uint32_t> && !std::is_same_v<data_t, uint64_t>) {
        try {
            if (!val.empty() && val[0] == '-') {
                throw std::out_of_range("negative value for unsigned type");
            }
            size_t pos;
            unsigned long long tmp = std::stoull(val, &pos);
            if (pos != val.length()) {
                throw std::invalid_argument("trailing characters");
            }
            if (tmp > std::numeric_limits<data_t>::max()) {
                throw std::out_of_range("value out of range");
            }
            return static_cast<data_t>(tmp);
        } catch (std::invalid_argument&) {
            throw uhd::runtime_error(
                std::string("Cannot convert `") + val + "' to numeric type!");
        } catch (std::out_of_range&) {
            throw uhd::runtime_error(
                std::string("Cannot convert `") + val + "' to numeric type!");
        }
    } else {
        throw uhd::runtime_error("Cannot convert from string!");
    }
}
 
// Specializations of `uhd::cast::from_str()` for supported data types

template <>
UHD_API bool from_str(const std::string& val);

template <>
UHD_API double from_str(const std::string& val);

template <>
UHD_API int from_str(const std::string& val);

template <>
UHD_API uint8_t from_str(const std::string& val);

template <>
UHD_API uint16_t from_str(const std::string& val);

template <>
UHD_API uint32_t from_str(const std::string& val);

template <>
UHD_API uint64_t from_str(const std::string& val);

template <>
inline UHD_API std::string from_str(const std::string& val)
{
    return val;
}

UHD_API std::string to_ordinal_string(int val);

 
// Type trait to detect if a type has a to_string() method
namespace detail {
template <typename T>
auto has_to_string_method_impl(int)
    -> decltype(std::declval<T>().to_string(), std::true_type{});
template <typename T>
auto has_to_string_method_impl(...) -> std::false_type;
template <typename T>
using has_to_string_method = decltype(has_to_string_method_impl<T>(0));
} // namespace detail

template <typename T>
auto to_str(const T& val) -> std::enable_if_t<
    std::is_arithmetic_v<
        T> && !std::is_floating_point_v<T> && !std::is_same_v<T, int8_t> && !std::is_same_v<T, uint8_t> && !std::is_enum_v<T> && !detail::has_to_string_method<T>::value,
    decltype(std::to_string(val))>
{
    return std::to_string(val);
}

template <typename T>
auto to_str(const T& val) -> std::enable_if_t<std::is_enum_v<T>, std::string>
{
    return std::to_string(static_cast<std::underlying_type_t<T>>(val));
}

template <typename T>
auto to_str(const T& val) -> std::enable_if_t<
    std::is_floating_point_v<T> && !detail::has_to_string_method<T>::value,
    std::string>
{
    std::ostringstream oss;
    oss.imbue(std::locale::classic());
    oss.precision(std::numeric_limits<T>::max_digits10);
    oss << val;
    return oss.str();
}
 
// Special handling for int8_t and uint8_t since std::to_string treats them as chars

template <typename T>
auto to_str(const T& val)
    -> std::enable_if_t<std::is_same_v<T, int8_t> || std::is_same_v<T, signed char>,
        std::string>
{
    return std::to_string(static_cast<int>(val));
}

template <typename T>
auto to_str(const T& val)
    -> std::enable_if_t<std::is_same_v<T, uint8_t> || std::is_same_v<T, unsigned char>,
        std::string>
{
    return std::to_string(static_cast<unsigned int>(val));
}

template <typename T>
std::string to_str(const std::complex<T>& val)
{
    std::string real_str = to_str(val.real());
    T imag_val           = val.imag();
 
    if (imag_val >= 0) {
        return real_str + "+j" + to_str(imag_val);
    } else {
        return real_str + "-j" + to_str(-imag_val);
    }
}

template <typename T>
auto to_str(const T& val)
    -> std::enable_if_t<std::is_convertible_v<decltype(val.to_string()), std::string>,
        std::string>
{
    return val.to_string();
}

inline std::string to_str(const std::string& val)
{
    return val;
}
 
inline std::string to_str(const char* val)
{
    return std::string(val);
}
 
}} // namespace uhd::cast