NekoCWD/libcamera
NekoCWD/libcamera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 7 Wiki Activity Actions

libcamera: yaml_parser: Use std::from_chars()

Browse source 
std::from_chars(), introduced in C++17, is a fast, locale-independent
string-to-arithmetic conversion function. The C++ standard library
provides overloads for all integer types, making it a prime candidate to
replace the manual handling of integer sizes in the YamlParser string to
integer conversion.

Compared to std::strtol(), std::from_chars() doesn't recognize the '0x'
prefix or '+' prefix, and doesn't ignore leading white space. As the
YamlParser doesn't require those features, std::from_chars() can be used
safely, reducing the amount of code.

C++17 also requires the standard C++ library to provide overloads for
floating-point types, but libc++ does not implement those. The float and
bool implementations of YamlParser::Getter::get() are therefore kept
as-is.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Jacopo Mondi <jacopo.mondi@ideasonboard.com>
Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
This commit is contained in:
Laurent Pinchart 2024-11-11 13:02:30 +02:00
parent 6d9baefca8
commit 5c71df927d
2 changed files with 29 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/libcamera/internal/yaml_parser.h
View file

@ -224,7 +224,7 @@ private:
Empty, Empty,
}; };
template<typename T> template<typename T, typename Enable = void>
struct Getter { struct Getter {
std::optional<T> get(const YamlObject &obj) const; std::optional<T> get(const YamlObject &obj) const;
}; };

160
src/libcamera/yaml_parser.cpp
View file

@ -7,6 +7,7 @@
#include "libcamera/internal/yaml_parser.h" #include "libcamera/internal/yaml_parser.h"
#include <charconv>
#include <cstdlib> #include <cstdlib>
#include <errno.h> #include <errno.h>
#include <functional> #include <functional>
@ -146,151 +147,38 @@ YamlObject::Getter<bool>::get(const YamlObject &obj) const
return std::nullopt; return std::nullopt;
} }
namespace { template<typename T>
struct YamlObject::Getter<T, std::enable_if_t<
bool parseSignedInteger(const std::string &str, long min, long max, std::is_same_v<int8_t, T> ||
long *result) std::is_same_v<uint8_t, T> ||
{ std::is_same_v<int16_t, T> ||
if (str == "") std::is_same_v<uint16_t, T> ||
return false; std::is_same_v<int32_t, T> ||
std::is_same_v<uint32_t, T>>>
char *end;
errno = 0;
long value = std::strtol(str.c_str(), &end, 10);
if ('\0' != *end || errno == ERANGE || value < min || value > max)
return false;
*result = value;
return true;
}
bool parseUnsignedInteger(const std::string &str, unsigned long max,
unsigned long *result)
{
if (str == "")
return false;
/*
* strtoul() accepts strings representing a negative number, in which
* case it negates the converted value. We don't want to silently accept
* negative values and return a large positive number, so check for a
* minus sign (after optional whitespace) and return an error.
*/
std::size_t found = str.find_first_not_of(" \t");
if (found != std::string::npos && str[found] == '-')
return false;
char *end;
errno = 0;
unsigned long value = std::strtoul(str.c_str(), &end, 10);
if ('\0' != *end || errno == ERANGE || value > max)
return false;
*result = value;
return true;
}
} /* namespace */
template<>
std::optional<int8_t>
YamlObject::Getter<int8_t>::get(const YamlObject &obj) const
{ {
std::optional<T> get(const YamlObject &obj) const
{
if (obj.type_ != Type::Value) if (obj.type_ != Type::Value)
return std::nullopt; return std::nullopt;
long value; const std::string &str = obj.value_;
T value;
if (!parseSignedInteger(obj.value_, std::numeric_limits<int8_t>::min(), auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(),
std::numeric_limits<int8_t>::max(), &value)) value);
if (ptr != str.data() + str.size() || ec != std::errc())
return std::nullopt; return std::nullopt;
return value; return value;
} }
};
template<> template struct YamlObject::Getter<int8_t>;
std::optional<uint8_t> template struct YamlObject::Getter<uint8_t>;
YamlObject::Getter<uint8_t>::get(const YamlObject &obj) const template struct YamlObject::Getter<int16_t>;
{ template struct YamlObject::Getter<uint16_t>;
if (obj.type_ != Type::Value) template struct YamlObject::Getter<int32_t>;
return std::nullopt; template struct YamlObject::Getter<uint32_t>;
unsigned long value;
if (!parseUnsignedInteger(obj.value_, std::numeric_limits<uint8_t>::max(),
&value))
return std::nullopt;
return value;
}
template<>
std::optional<int16_t>
YamlObject::Getter<int16_t>::get(const YamlObject &obj) const
{
if (obj.type_ != Type::Value)
return std::nullopt;
long value;
if (!parseSignedInteger(obj.value_, std::numeric_limits<int16_t>::min(),
std::numeric_limits<int16_t>::max(), &value))
return std::nullopt;
return value;
}
template<>
std::optional<uint16_t>
YamlObject::Getter<uint16_t>::get(const YamlObject &obj) const
{
if (obj.type_ != Type::Value)
return std::nullopt;
unsigned long value;
if (!parseUnsignedInteger(obj.value_, std::numeric_limits<uint16_t>::max(),
&value))
return std::nullopt;
return value;
}
template<>
std::optional<int32_t>
YamlObject::Getter<int32_t>::get(const YamlObject &obj) const
{
if (obj.type_ != Type::Value)
return std::nullopt;
long value;
if (!parseSignedInteger(obj.value_, std::numeric_limits<int32_t>::min(),
std::numeric_limits<int32_t>::max(), &value))
return std::nullopt;
return value;
}
template<>
std::optional<uint32_t>
YamlObject::Getter<uint32_t>::get(const YamlObject &obj) const
{
if (obj.type_ != Type::Value)
return std::nullopt;
unsigned long value;
if (!parseUnsignedInteger(obj.value_, std::numeric_limits<uint32_t>::max(),
&value))
return std::nullopt;
return value;
}
template<> template<>
std::optional<float> std::optional<float>