[libsigrok.git] / bindings / cxx / ConfigKey_methods.cpp

#include <config.h>

const DataType *ConfigKey::data_type() const
{
	const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
	if (!info)
		throw Error(SR_ERR_NA);
	return DataType::get(info->datatype);
}

std::string ConfigKey::identifier() const
{
	const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
	if (!info)
		throw Error(SR_ERR_NA);
	return valid_string(info->id);
}

std::string ConfigKey::description() const
{
	const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
	if (!info)
		throw Error(SR_ERR_NA);
	return valid_string(info->name);
}

const ConfigKey *ConfigKey::get_by_identifier(std::string identifier)
{
	const struct sr_key_info *info = sr_key_info_name_get(SR_KEY_CONFIG, identifier.c_str());
	if (!info)
		throw Error(SR_ERR_ARG);
	return get(info->key);
}

#ifndef HAVE_STOI_STOD

/* Fallback implementation of stoi and stod */

#include <cstdlib>
#include <cerrno>
#include <stdexcept>
#include <limits>

static inline int stoi( const std::string& str )
{
	char *endptr;
	errno = 0;
	const long ret = std::strtol(str.c_str(), &endptr, 10);
	if (endptr == str.c_str())
		throw std::invalid_argument("stoi");
	else if (errno == ERANGE ||
		 ret < std::numeric_limits<int>::min() ||
		 ret > std::numeric_limits<int>::max())
		throw std::out_of_range("stoi");
	else
		return ret;
}

static inline double stod( const std::string& str )
{
	char *endptr;
	errno = 0;
	const double ret = std::strtod(str.c_str(), &endptr);
	if (endptr == str.c_str())
		throw std::invalid_argument("stod");
	else if (errno == ERANGE)
		throw std::out_of_range("stod");
	else
		return ret;
}
#endif

#ifndef HAVE_STOUL

/* Fallback implementation of stoul. */

#include <cerrno>
#include <cstdlib>
#include <limits>
#include <stdexcept>

static inline unsigned long stoul(const std::string &str)
{
	char *endptr;
	unsigned long ret;
	errno = 0;
	ret = std::strtoul(str.c_str(), &endptr, 10);
	if (endptr == str.c_str())
		throw std::invalid_argument("stoul");
	/*
	 * TODO Convert to a larger/wider intermediate data type?
	 * Because after conversion into the very target type, the
	 * range check is assumed to be ineffective.
	 */
	if (errno == ERANGE ||
		ret < std::numeric_limits<unsigned long>::min() ||
		ret > std::numeric_limits<unsigned long>::max())
		throw std::out_of_range("stoul");
	return ret;
}
#endif

Glib::VariantBase ConfigKey::parse_string(std::string value, enum sr_datatype dt)
{
	GVariant *variant;
	uint64_t p, q;

	switch (dt)
	{
		case SR_T_UINT64:
			check(sr_parse_sizestring(value.c_str(), &p));
			variant = g_variant_new_uint64(p);
			break;
		case SR_T_STRING:
			variant = g_variant_new_string(value.c_str());
			break;
		case SR_T_BOOL:
			variant = g_variant_new_boolean(sr_parse_boolstring(value.c_str()));
			break;
		case SR_T_FLOAT:
			try {
				variant = g_variant_new_double(stod(value));
			} catch (invalid_argument&) {
				throw Error(SR_ERR_ARG);
			}
			break;
		case SR_T_RATIONAL_PERIOD:
			check(sr_parse_period(value.c_str(), &p, &q));
			variant = g_variant_new("(tt)", p, q);
			break;
		case SR_T_RATIONAL_VOLT:
			check(sr_parse_voltage(value.c_str(), &p, &q));
			variant = g_variant_new("(tt)", p, q);
			break;
		case SR_T_INT32:
			try {
				variant = g_variant_new_int32(stoi(value));
			} catch (invalid_argument&) {
				throw Error(SR_ERR_ARG);
			}
			break;
		default:
			throw Error(SR_ERR_BUG);
	}

	return Glib::VariantBase(variant, false);
}

Glib::VariantBase ConfigKey::parse_string(std::string value) const
{
	enum sr_datatype dt = (enum sr_datatype)(data_type()->id());
	return parse_string(value, dt);
}
Commit	Line	Data
1e95832b GS	1	#include <config.h>
1e95832b GS	2
3b161085	3	const DataType *ConfigKey::data_type() const
c23c8659	4	{
21d1bec6	5	const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
c23c8659 ML	6	if (!info)
	7	throw Error(SR_ERR_NA);
	8	return DataType::get(info->datatype);
	9	}
	10
6c6dd732	11	std::string ConfigKey::identifier() const
c23c8659	12	{
21d1bec6	13	const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
c23c8659 ML	14	if (!info)
	15	throw Error(SR_ERR_NA);
	16	return valid_string(info->id);
	17	}
	18
6c6dd732	19	std::string ConfigKey::description() const
c23c8659	20	{
21d1bec6	21	const struct sr_key_info *info = sr_key_info_get(SR_KEY_CONFIG, id());
c23c8659 ML	22	if (!info)
	23	throw Error(SR_ERR_NA);
	24	return valid_string(info->name);
	25	}
	26
6c6dd732	27	const ConfigKey *ConfigKey::get_by_identifier(std::string identifier)
c23c8659	28	{
2fb60e23	29	const struct sr_key_info *info = sr_key_info_name_get(SR_KEY_CONFIG, identifier.c_str());
c23c8659 ML	30	if (!info)
	31	throw Error(SR_ERR_ARG);
	32	return get(info->key);
	33	}
	34
d92de05a MC	35	#ifndef HAVE_STOI_STOD
	36
	37	/* Fallback implementation of stoi and stod */
	38
	39	#include <cstdlib>
	40	#include <cerrno>
	41	#include <stdexcept>
	42	#include <limits>
	43
	44	static inline int stoi( const std::string& str )
	45	{
	46	char *endptr;
	47	errno = 0;
	48	const long ret = std::strtol(str.c_str(), &endptr, 10);
	49	if (endptr == str.c_str())
	50	throw std::invalid_argument("stoi");
	51	else if (errno == ERANGE \|\|
	52	ret < std::numeric_limits<int>::min() \|\|
	53	ret > std::numeric_limits<int>::max())
	54	throw std::out_of_range("stoi");
	55	else
	56	return ret;
	57	}
	58
	59	static inline double stod( const std::string& str )
	60	{
	61	char *endptr;
	62	errno = 0;
	63	const double ret = std::strtod(str.c_str(), &endptr);
	64	if (endptr == str.c_str())
	65	throw std::invalid_argument("stod");
	66	else if (errno == ERANGE)
	67	throw std::out_of_range("stod");
	68	else
	69	return ret;
	70	}
	71	#endif
	72
f806de18 GS	73	#ifndef HAVE_STOUL
	74
	75	/* Fallback implementation of stoul. */
	76
	77	#include <cerrno>
	78	#include <cstdlib>
	79	#include <limits>
	80	#include <stdexcept>
	81
	82	static inline unsigned long stoul(const std::string &str)
	83	{
	84	char *endptr;
	85	unsigned long ret;
	86	errno = 0;
	87	ret = std::strtoul(str.c_str(), &endptr, 10);
	88	if (endptr == str.c_str())
	89	throw std::invalid_argument("stoul");
	90	/*
	91	* TODO Convert to a larger/wider intermediate data type?
	92	* Because after conversion into the very target type, the
	93	* range check is assumed to be ineffective.
	94	*/
	95	if (errno == ERANGE \|\|
	96	ret < std::numeric_limits<unsigned long>::min() \|\|
	97	ret > std::numeric_limits<unsigned long>::max())
	98	throw std::out_of_range("stoul");
	99	return ret;
	100	}
	101	#endif
	102
6c6dd732	103	Glib::VariantBase ConfigKey::parse_string(std::string value, enum sr_datatype dt)
c23c8659 ML	104	{
	105	GVariant *variant;
	106	uint64_t p, q;
	107
61a6d983	108	switch (dt)
c23c8659 ML	109	{
	110	case SR_T_UINT64:
	111	check(sr_parse_sizestring(value.c_str(), &p));
	112	variant = g_variant_new_uint64(p);
	113	break;
	114	case SR_T_STRING:
	115	variant = g_variant_new_string(value.c_str());
	116	break;
	117	case SR_T_BOOL:
	118	variant = g_variant_new_boolean(sr_parse_boolstring(value.c_str()));
	119	break;
	120	case SR_T_FLOAT:
4aa9a1e5 ML	121	try {
4aa9a1e5 ML	122	variant = g_variant_new_double(stod(value));
0875f11d	123	} catch (invalid_argument&) {
4aa9a1e5 ML	124	throw Error(SR_ERR_ARG);
4aa9a1e5 ML	125	}
c23c8659 ML	126	break;
	127	case SR_T_RATIONAL_PERIOD:
	128	check(sr_parse_period(value.c_str(), &p, &q));
	129	variant = g_variant_new("(tt)", p, q);
	130	break;
	131	case SR_T_RATIONAL_VOLT:
	132	check(sr_parse_voltage(value.c_str(), &p, &q));
	133	variant = g_variant_new("(tt)", p, q);
	134	break;
	135	case SR_T_INT32:
4aa9a1e5 ML	136	try {
4aa9a1e5 ML	137	variant = g_variant_new_int32(stoi(value));
0875f11d	138	} catch (invalid_argument&) {
4aa9a1e5 ML	139	throw Error(SR_ERR_ARG);
4aa9a1e5 ML	140	}
c23c8659 ML	141	break;
	142	default:
	143	throw Error(SR_ERR_BUG);
	144	}
	145
7009a392	146	return Glib::VariantBase(variant, false);
c23c8659 ML	147	}
c23c8659 ML	148
6c6dd732	149	Glib::VariantBase ConfigKey::parse_string(std::string value) const
61a6d983 GS	150	{
	151	enum sr_datatype dt = (enum sr_datatype)(data_type()->id());
	152	return parse_string(value, dt);
	153	}