utility.hpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: Copyright (c) 2022-2026 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 ContainerT>
concept RangeContainer = std::ranges::range<ContainerT>
                      && requires(ContainerT c) {
                             typename ContainerT::value_type;
                         };

template <typename ValueT, typename StringConverterT>
concept StringConverter = std::same_as<
    std::invoke_result_t<StringConverterT, ValueT>,
    std::string
>;

template <RangeContainer ContainerT, typename StringConverterT>
requires StringConverter<typename ContainerT::value_type, StringConverterT>
[[nodiscard]] inline std::string ToString(
    const ContainerT&  container,
    const std::string& value_separator,
    StringConverterT   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 ContainerT>
concept FileContainer = std::ranges::range<ContainerT>
                     && std::default_initializable<ContainerT>
                     && std::same_as<
                            typename ContainerT::value_type,
                            std::filesystem::path
                     >
                     && requires(ContainerT c, std::filesystem::path p) {
                            c.push_back(p);
                            c.empty();
                            typename ContainerT::value_type;
                        };

[[nodiscard]] inline std::string ToString(
    const FileContainer auto& container,
    const std::string&        separator = ", "
)
{
    return ToString(
        container,
        separator,
        [](const std::filesystem::path& path) {
            return path.string();
        }
    );
}
} /* namespace Utility */
} /* namespace Recognition */
 
#endif /* UTILITY_HPP */