algorithm.h

#pragma once
 
#include <algorithm>
#include <string>
#include <vector>
 
#include <utility>
 
//#include "lib_begin.h"
 
namespace cgv {
namespace utils {
 
template <class T1 = void, class T2 = void>
struct get_first {
    constexpr T1 operator()(const std::pair<T1, T2>& pair) const {
        return pair.first;
    }
};
 
template <>
struct get_first<void, void> {
    template <class T1, class T2>
    constexpr auto operator()(const std::pair<T1, T2>& pair) const
        -> decltype(static_cast<const T1&>(pair.first)) {
        return static_cast<const T1&>(pair.first);
    }
};
 
template <class T1 = void, class T2 = void>
struct get_second {
    constexpr T2 operator()(const std::pair<T1, T2>& pair) const {
        return pair.second;
    }
};
 
template <>
struct get_second<void, void> {
    template <class T1, class T2>
    constexpr auto operator()(const std::pair<T1, T2>& pair) const
        -> decltype(static_cast<const T2&>(pair.second)) {
        return static_cast<const T2&>(pair.second);
    }
};
 
template<typename ForwardIt, typename T>
T min_value(ForwardIt first, ForwardIt last, T fallback) {
    auto it = std::min_element(first, last);
    return it != last ? static_cast<T>(*it) : fallback;
}
 
template<typename ForwardIt, typename UnaryOp, typename T>
T min_value(ForwardIt first, ForwardIt last, UnaryOp operation, T fallback) {
    auto it = std::min_element(first, last, [&operation](const auto& left, const auto& right) {
        return operation(left) < operation(right);
    });
    return it != last ? static_cast<T>(operation(*it)) : fallback;
}
 
template<typename ForwardIt, typename T>
T max_value(ForwardIt first, ForwardIt last, T fallback) {
    auto it = std::max_element(first, last);
    return it != last ? static_cast<T>(*it) : fallback;
}
 
template<typename ForwardIt, typename UnaryOp, typename T>
T max_value(ForwardIt first, ForwardIt last, UnaryOp operation, T fallback) {
    auto it = std::max_element(first, last, [&operation](const auto& left, const auto& right) {
        return operation(left) < operation(right);
    });
    return it != last ? static_cast<T>(operation(*it)) : fallback;
}
 
template <class InputIt, class UnaryOp>
std::string transform_join(const InputIt first, const InputIt last, UnaryOp operation, const std::string& separator, bool trailing_separator = false) {
    std::string res = "";
    if(last > first) {
        for(auto curr = first; curr != last; ++curr) {
            res += operation(*curr);
            if(last - curr > 1 || trailing_separator)
                res += separator;
        }
    }
    return res;
}
 
template <class InputIt>
std::string join(const InputIt first, const InputIt last, const std::string& separator, bool trailing_separator = false) {
    return transform_join(first, last, [](const auto& val) { return to_string(val); }, separator, trailing_separator);
}
 
template<class InputIt, class OutputIt>
OutputIt pair_adjacent(const InputIt first, const InputIt last, OutputIt d_first) {
    if(std::distance(first, last) > 1) {
        return std::transform(first, std::prev(last), std::next(first), d_first, [](const auto& a, const auto& b) {
            return std::make_pair(a, b);
        });
    }
    return d_first;
}
 
template<class InputIt>
std::vector<std::pair<typename InputIt::value_type, typename InputIt::value_type>> pair_adjacent(const InputIt first, const InputIt last) {
    std::vector<std::pair<typename InputIt::value_type, typename InputIt::value_type>> res;
    pair_adjacent(first, last, std::back_inserter(res));
    return res;
}
 
} // namespace utils
} // namespace cgv
 
//#include <cgv/config/lib_end.h>