utility.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2025 Oğuz Toraman <oguz.toraman@tutanota.com> */
/* SPDX-License-Identifier: LGPL-3.0-only */
 
#ifndef UTILITY_HPP
#define UTILITY_HPP
 
#include <algorithm>
#include <concepts>
#include <filesystem>
#include <functional>
#include <ranges>
#include <string>
 
namespace recognition {
 
namespace utility {
 
template <typename ContainerType>
concept range_container = std::ranges::range<ContainerType>
                       && requires(ContainerType c) {
                              typename ContainerType::value_type;
                          };
 
template <typename ValueType, typename StringConverterType>
concept string_converter = std::same_as<
    std::invoke_result_t<StringConverterType, ValueType>,
    std::string>;
 
template <range_container ContainerType, typename StringConverterType>
requires string_converter<
    typename ContainerType::value_type,
    StringConverterType>
[[nodiscard]] inline std::string to_string(
    const ContainerType& container,
    const std::string&   value_separator,
    StringConverterType  string_converter
)
{
    if (container.empty()) {
        return {};
    }
    return std::ranges::fold_left(
        std::ranges::next(std::ranges::begin(container)),
        std::ranges::end(container),
        std::invoke(string_converter, *std::ranges::begin(container)),
        [&](const auto& left, const auto& right) {
            return left + value_separator
                 + std::invoke(string_converter, right);
        }
    );
}
 
template <typename ContainerType>
concept file_container = std::ranges::range<ContainerType>
                      && std::default_initializable<ContainerType>
                      && std::same_as<
                             typename ContainerType::value_type,
                             std::filesystem::path>
                      && requires(ContainerType c, std::filesystem::path p) {
                             c.push_back(p);
                             c.empty();
                             typename ContainerType::value_type;
                         };
 
[[nodiscard]] inline std::string to_string(
    const file_container auto& container,
    const std::string&         separator = ", "
)
{
    return to_string(
        container,
        separator,
        [](const std::filesystem::path& path) {
            return path.string();
        }
    );
}
 
} /* namespace utility */
 
} /* namespace recognition */
 
#endif /* UTILITY_HPP */