libcamera/jmondi/libcamera.git - Jacopo Mondi's clone of libcamera

diff options

Diffstat (limited to 'src/libcamera/meson.build')

-rw-r--r--

1 files changed, 2 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2022, Google Inc. * * yaml_parser.cpp - libcamera YAML parsing helper */ #include "libcamera/internal/yaml_parser.h" #include <cstdlib> #include <errno.h> #include <functional> #include <limits> #include <libcamera/base/file.h> #include <libcamera/base/log.h> #include <yaml.h> /** * \file libcamera/internal/yaml_parser.h * \brief A YAML parser helper */ namespace libcamera { LOG_DEFINE_CATEGORY(YamlParser) namespace { /* Empty static YamlObject as a safe result for invalid operations */ static const YamlObject empty; } /* namespace */ /** * \class YamlObject * \brief A class representing the tree structure of the YAML content * * The YamlObject class represents the tree structure of YAML content. A * YamlObject can be a dictionary or list of YamlObjects or a value if a tree * leaf. */ YamlObject::YamlObject() : type_(Type::Value) { } YamlObject::~YamlObject() = default; /** * \fn YamlObject::isValue() * \brief Return whether the YamlObject is a value * * \return True if the YamlObject is a value, false otherwise */ /** * \fn YamlObject::isList() * \brief Return whether the YamlObject is a list * * \return True if the YamlObject is a list, false otherwise */ /** * \fn YamlObject::isDictionary() * \brief Return whether the YamlObject is a dictionary * * \return True if the YamlObject is a dictionary, false otherwise */ /** * \fn YamlObject::size() * \brief Retrieve the number of elements in a dictionary or list YamlObject * * This function retrieves the size of the YamlObject, defined as the number of * child elements it contains. Only YamlObject instances of Dictionary or List * types have a size, calling this function on other types of instances is * invalid and results in undefined behaviour. * * \return The size of the YamlObject */ std::size_t YamlObject::size() const { switch (type_) { case Type::Dictionary: case Type::List: return list_.size(); default: return 0; } } /** * \fn template<typename T> YamlObject::get<T>() const * \brief Parse the YamlObject as a \a T value * * This function parses the value of the YamlObject as a \a T object, and * returns the value. If parsing fails (usually because the YamlObject doesn't * store a \a T value), std::nullopt is returned. * * \return The YamlObject value, or std::nullopt if parsing failed */ /** * \fn template<typename T> YamlObject::get<T>(const T &defaultValue) const * \brief Parse the YamlObject as a \a T value * \param[in] defaultValue The default value when failing to parse * * This function parses the value of the YamlObject as a \a T object, and * returns the value. If parsing fails (usually because the YamlObject doesn't * store a \a T value), the \a defaultValue is returned. * * \return The YamlObject value, or \a defaultValue if parsing failed */ #ifndef __DOXYGEN__ template<> std::optional<bool> YamlObject::get() const { if (type_ != Type::Value) return std::nullopt; if (value_ == "true") return true; else if (value_ == "false") return false; return std::nullopt; } namespace { bool parseSignedInteger(const std::string &str, long min, long max, long *result) { if (str == "") return false; 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::get() const { if (type_ != Type::Value) return std::nullopt; long value; if (!parseSignedInteger(value_, std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max(), &value)) return std::nullopt; return value; } template<> std::optional<uint8_t> YamlObject::get() const { if (type_ != Type::Value) return std::nullopt; unsigned long value; if (!parseUnsignedInteger(value_, std::numeric_limits<uint8_t>::max(), &value)) return std::nullopt; return value; } template<> std::optional<int16_t> YamlObject::get() const { if (type_ != Type::Value) return std::nullopt; long value; if (!parseSignedInteger(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::get() const { if (type_ != Type::Value) return std::nullopt; unsigned long value; if (!parseUnsignedInteger(value_, std::numeric_limits<uint16_t>::max(), &value)) return std::nullopt; return value; } template<> std::optional<int32_t> YamlObject::get() const { if (type_ != Type::Value) return std::nullopt; long value; if (!parseSignedInteger(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::get() const { if (type_ != Type::Value) return std::nullopt; unsigned long value; if (!parseUnsignedInteger(value_, std::numeric_limits<uint32_t>::max(), &value)) return std::nullopt; return value; } template<> std::optional<double> YamlObject::get() const { if (type_ != Type::Value) return std::nullopt; if (value_ == "") return std::nullopt; char *end; errno = 0; double value = std::strtod(value_.c_str(), &end); if ('\0' != *end || errno == ERANGE) return std::nullopt; return value; } template<> std::optional<std::string> YamlObject::get() const { if (type_ != Type::Value) return std::nullopt; return value_; } template<> std::optional<Size> YamlObject::get() const { if (type_ != Type::List) return std::nullopt; if (list_.size() != 2) return std::nullopt; auto width = list_[0].value->get<uint32_t>(); if (!width) return std::nullopt; auto height = list_[1].value->get<uint32_t>(); if (!height) return std::nullopt; return Size(*width, *height); } #endif /* __DOXYGEN__ */ /** * \fn template<typename T> YamlObject::getList<T>() const * \brief Parse the YamlObject as a list of \a T * * This function parses the value of the YamlObject as a list of \a T objects, * and returns the value as a \a std::vector<T>. If parsing fails, std::nullopt * is returned. * * \return The YamlObject value as a std::vector<T>, or std::nullopt if parsing * failed */ #ifndef __DOXYGEN__ template<typename T, std::enable_if_t< std::is_same_v<bool, T> || std::is_same_v<double, T> || std::is_same_v<int8_t, T> || std::is_same_v<uint8_t, T> || std::is_same_v<int16_t, T> || std::is_same_v<uint16_t, T> || std::is_same_v<int32_t, T> || std::is_same_v<uint32_t, T> || std::is_same_v<std::string, T> || std::is_same_v<Size, T>> *> std::optional<std::vector<T>> YamlObject::getList() const { if (type_ != Type::List) return std::nullopt; std::vector<T> values; values.reserve(list_.size()); for (const YamlObject &entry : asList()) { const auto value = entry.get<T>(); if (!value) return std::nullopt; values.emplace_back(*value); } return values; } template std::optional<std::vector<bool>> YamlObject::getList<bool>() const; template std::optional<std::vector<double>> YamlObject::getList<double>() const; template std::optional<std::vector<int8_t>> YamlObject::getList<int8_t>() const; template std::optional<std::vector<uint8_t>> YamlObject::getList<uint8_t>() const; template std::optional<std::vector<int16_t>> YamlObject::getList<int16_t>() const; template std::optional<std::vector<uint16_t>> YamlObject::getList<uint16_t>() const; template std::optional<std::vector<int32_t>> YamlObject::getList<int32_t>() const; template std::optional<std::vector<uint32_t>> YamlObject::getList<uint32_t>() const; template std::optional<std::vector<std::string>> YamlObject::getList<std::string>() const; template std::optional<std::vector<Size>> YamlObject::getList<Size>() const; #endif /* __DOXYGEN__ */ /** * \fn YamlObject::asDict() const * \brief Wrap a dictionary YamlObject in an adapter that exposes iterators * * The YamlObject class doesn't directly implement iterators, as the iterator * type depends on whether the object is a Dictionary or List. This function * wraps a YamlObject of Dictionary type into an adapter that exposes * iterators, as well as begin() and end() functions, allowing usage of * range-based for loops with YamlObject. As YAML mappings are not ordered, the * iteration order is not specified. * * The iterator's value_type is a * <em>std::pair<const std::string &, const \ref YamlObject &></em>. * * If the YamlObject is not of Dictionary type, the returned adapter operates * as an empty container. * * \return An adapter of unspecified type compatible with range-based for loops */ /** * \fn YamlObject::asList() const * \brief Wrap a list YamlObject in an adapter that exposes iterators * * The YamlObject class doesn't directly implement iterators, as the iterator * type depends on whether the object is a Dictionary or List. This function * wraps a YamlObject of List type into an adapter that exposes iterators, as * well as begin() and end() functions, allowing usage of range-based for loops * with YamlObject. As YAML lists are ordered, the iteration order is identical * to the list order in the YAML data. * * The iterator's value_type is a <em>const YamlObject &</em>. * * If the YamlObject is not of List type, the returned adapter operates as an * empty container. * * \return An adapter of unspecified type compatible with range-based for loops */ /** * \fn YamlObject::operator[](std::size_t index) const * \brief Retrieve the element from list YamlObject by index * * This function retrieves an element of the YamlObject. Only YamlObject * instances of List type associate elements with index, calling this function * on other types of instances is invalid and results in undefined behaviour. * * \return The YamlObject as an element of the list */ const YamlObject &YamlObject::operator[](std::size_t index) const { if (type_ != Type::List || index >= size()) return empty; return *list_[index].value; } /** * \fn YamlObject::contains() * \brief Check if an element of a dictionary exists * * This function check if the YamlObject contains an element. Only YamlObject * instances of Dictionary type associate elements with names, calling this * function on other types of instances is invalid and results in undefined * behaviour. * * \return True if an element exists, false otherwise */ bool YamlObject::contains(const std::string &key) const { if (dictionary_.find(std::ref(key)) == dictionary_.end()) return false; return true; } /** * \fn YamlObject::operator[](const std::string &key) const * \brief Retrieve a member by name from the dictionary * * This function retrieve a member of a YamlObject by name. Only YamlObject * instances of Dictionary type associate elements with names, calling this * function on other types of instances is invalid and results in undefined * behaviour. * * \return The YamlObject corresponding to the \a key member */ const YamlObject &YamlObject::operator[](const std::string &key) const { if (type_ != Type::Dictionary || !contains(key)) return empty; auto iter = dictionary_.find(key); return *iter->second; } #ifndef __DOXYGEN__ class YamlParserContext { public: YamlParserContext(); ~YamlParserContext(); int init(File &file); int parseContent(YamlObject &yamlObject); private: struct EventDeleter { void operator()(yaml_event_t *event) const { yaml_event_delete(event); delete event; } }; using EventPtr = std::unique_ptr<yaml_event_t, EventDeleter>; static int yamlRead(void *data, unsigned char *buffer, size_t size, size_t *sizeRead); EventPtr nextEvent(); void readValue(std::string &value, EventPtr event); int parseDictionaryOrList(YamlObject::Type type, const std::function<int(EventPtr event)> &parseItem); int parseNextYamlObject(YamlObject &yamlObject, EventPtr event); bool parserValid_; yaml_parser_t parser_; }; /** * \class YamlParserContext * \brief Class for YamlParser parsing and context data * * The YamlParserContext class stores the internal yaml_parser_t and provides * helper functions to do event-based parsing for YAML files. */ YamlParserContext::YamlParserContext() : parserValid_(false) { } /** * \class YamlParserContext * \brief Destructor of YamlParserContext */ YamlParserContext::~YamlParserContext() { if (parserValid_) { yaml_parser_delete(&parser_); parserValid_ = false; } } /** * \fn YamlParserContext::init() * \brief Initialize a parser with an opened file for parsing * \param[in] fh The YAML file to parse * * Prior to parsing the YAML content, the YamlParserContext must be initialized * with a file to create an internal parser. The file needs to stay valid until * parsing completes. * * \return 0 on success or a negative error code otherwise * \retval -EINVAL The parser has failed to initialize */ int YamlParserContext::init(File &file) {


context:
space:
mode: