utils.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/formats/common/utils.hpp
/// @brief formats::common::GetAtPath and formats::common::RemoveAtPath utils for `Value` and `ValueBuilder`
/// @ingroup userver_universal
 
#include <cstddef>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <userver/formats/common/meta.hpp>
#include <userver/formats/common/transfer_tag.hpp>
#include <userver/formats/common/type.hpp>
#include <userver/utils/assert.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace formats::common {
 
namespace impl {
 
template <typename ValueBuilder>
ValueBuilder GetAtPath(ValueBuilder& parent, std::vector<std::string>&& path, std::size_t path_size) {
    UINVARIANT(path_size != 0, "attempt to get a ValueBuilder element on an empty path");
    if (path_size == 1) {
        return parent[std::move(path[0])];
    }
    std::optional<ValueBuilder> current_element;
 
    current_element.emplace(TransferTag(), parent[std::move(path[0])]);
    for (std::size_t i = 1; i < path_size - 1; i++) {
        current_element.emplace(TransferTag(), (*current_element)[std::move(path[i])]);
    }
    return (*current_element)[std::move(path[path_size - 1])];
}
 
}  // namespace impl
 
/// @brief Get the `Value` at `path` in `parent`.
/// @note For empty `path` this function returns `parent`.
/// @throws TypeMismatchException if there is a non-object node in the middle of `path`
template <common::IsFormatValue Value>
Value GetAtPath(Value parent, const std::vector<std::string>& path) {
    auto current_value = std::move(parent);
    for (const auto& current_key : path) {
        current_value = current_value[current_key];
    }
    return current_value;
}
 
/// @brief Get the `ValueBuilder` at `path` in `parent`.
/// @note `path` must not be empty.
/// @throws TypeMismatchException if there is a non-object node in the middle of `path`
template <typename ValueBuilder>
requires(!common::IsFormatValue<ValueBuilder>)
ValueBuilder GetAtPath(ValueBuilder& parent, std::vector<std::string>&& path) {
    return impl::GetAtPath(parent, std::move(path), path.size());
}
 
/// @brief Set the `new_value` along the `path` in the `parent`.
/// @note If `path` is empty it sets `new_value` to `parent`.
/// @throws TypeMismatchException if there is a non-object node in the middle of `path`
template <typename Value>
void SetAtPath(typename Value::Builder& parent, std::vector<std::string>&& path, Value new_value) {
    if (path.empty()) {
        parent = std::move(new_value);
    } else {
        common::GetAtPath(parent, std::move(path)) = std::move(new_value);
    }
}
 
/// @brief Remove the element along the `path` in the `parent`.
/// @note If `path` is empty or there is no node at `path`, this function does
/// nothing.
/// @throws TypeMismatchException if there is a non-object node in the middle of `path`
template <typename ValueBuilder>
void RemoveAtPath(ValueBuilder& parent, std::vector<std::string>&& path) {
    if (path.empty()) {
        parent = ValueBuilder();
    } else if (path.size() == 1) {
        parent.Remove(path[0]);
    } else {
        auto& key = path[path.size() - 1];
        impl::GetAtPath(parent, std::move(path), path.size() - 1).Remove(key);
    }
}
 
/// @brief Split `path` to `vector<std::string>` by dots.
/// @note If `path` has a double dot or a dot at the beginning or end, the result will contain an empty string.
/// @note Returns an empty `vector` if `path` is empty
std::vector<std::string> SplitPathString(std::string_view path);
 
}  // namespace formats::common
 
USERVER_NAMESPACE_END