Types.hpp

Go to the documentation of this file.

 
#pragma once
#include <SoapySDR/Config.hpp>
#include <SoapySDR/Types.h>
#include <type_traits>
#include <vector>
#include <string>
#include <map>
 
namespace SoapySDR
{
 
typedef std::map<std::string, std::string> Kwargs;
 
SOAPY_SDR_API Kwargs KwargsFromString(const std::string &markup);
 
SOAPY_SDR_API std::string KwargsToString(const Kwargs &args);
 
typedef std::vector<Kwargs> KwargsList;
 
template <typename Type>
Type StringToSetting(const std::string &s);
 
template <typename Type>
std::string SettingToString(const Type &s);
 
class SOAPY_SDR_API Range
{
public:
 
    Range(void);
 
    Range(const double minimum, const double maximum, const double step=0.0);
 
    double minimum(void) const;
 
    double maximum(void) const;
 
    double step(void) const;
 
private:
    double _min, _max, _step;
};
 
typedef std::vector<Range> RangeList;
 
class SOAPY_SDR_API ArgInfo
{
public:
 
    ArgInfo(void);
 
    std::string key;
 
    std::string value;
 
    std::string name;
 
    std::string description;
 
    std::string units;
 
    enum Type {BOOL, INT, FLOAT, STRING} type;
 
    Range range;
 
    std::vector<std::string> options;
 
    std::vector<std::string> optionNames;
};
 
typedef std::vector<ArgInfo> ArgInfoList;
 
}
 
inline double SoapySDR::Range::minimum(void) const
{
    return _min;
}
 
inline double SoapySDR::Range::maximum(void) const
{
    return _max;
}
 
inline double SoapySDR::Range::step(void) const
{
    return _step;
}
 
namespace SoapySDR {
namespace Detail {
 
 
//private implementation details for settings converters
 
template <typename Type>
typename std::enable_if<std::is_same<Type, bool>::value, Type>::type StringToSetting(const std::string &s)
{
    if (s == SOAPY_SDR_TRUE) return true;
    if (s == SOAPY_SDR_FALSE) return false;
 
    //zeros and empty strings are false
    if (s == "0") return false;
    if (s == "0.0") return false;
    if (s == "") return false;
 
    //other values are true
    return "true";
}
 
template <typename Type>
typename std::enable_if<not std::is_same<Type, bool>::value and std::is_integral<Type>::value and std::is_signed<Type>::value, Type>::type StringToSetting(const std::string &s)
{
    return Type(std::stoll(s));
}
 
template <typename Type>
typename std::enable_if<not std::is_same<Type, bool>::value and std::is_integral<Type>::value and std::is_unsigned<Type>::value, Type>::type StringToSetting(const std::string &s)
{
    return Type(std::stoull(s));
}
 
template <typename Type>
typename std::enable_if<std::is_floating_point<Type>::value, Type>::type StringToSetting(const std::string &s)
{
    return Type(std::stod(s));
}
 
template <typename Type>
typename std::enable_if<std::is_same<typename std::decay<Type>::type, std::string>::value, Type>::type StringToSetting(const std::string &s)
{
    return s;
}
 
inline std::string SettingToString(const bool &s)
{
    return s?SOAPY_SDR_TRUE:SOAPY_SDR_FALSE;
}
 
inline std::string SettingToString(const char *s)
{
    return s;
}
 
inline std::string SettingToString(const std::string &s)
{
    return s;
}
 
template <typename Type>
std::string SettingToString(const Type &s)
{
    return std::to_string(s);
}
 
}}
 
template <typename Type>
Type SoapySDR::StringToSetting(const std::string &s)
{
    return SoapySDR::Detail::StringToSetting<Type>(s);
}
 
template <typename Type>
std::string SoapySDR::SettingToString(const Type &s)
{
    return SoapySDR::Detail::SettingToString(s);
}