stdtypesutils.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_UTILS_STDTYPESUTILS_HPP_
#define MEDUSA_BITS_UTILS_STDTYPESUTILS_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/utils/assert.hpp>
#include <string>
#include <vector>
#include <tuple>
#include <type_traits>
 
namespace mm {
 
std::vector<std::string> split(const std::string& s, const std::string& delim);
std::vector<std::string> split(const std::string& s, char delim);
 
std::string join(const std::vector<std::string>& parts, const std::string& joiner);
std::string join(const std::vector<std::string>& parts, char joiner);
 
template<typename container_t>
container_t& sort(container_t& v) {
    std::sort(v.begin(), v.end());
    return v;
}
 
template<typename container_t, typename predicate_t>
container_t& sort(container_t& v, const predicate_t& pred) {
    std::sort(v.begin(), v.end(), pred);
    return v;
}
 
template<typename container_t>
container_t sorted(container_t v) {
    std::sort(v.begin(), v.end());
    return v;
}
 
template<typename container_t, typename predicate_t>
container_t sorted(container_t v, const predicate_t& pred) {
    std::sort(v.begin(), v.end(), pred);
    return v;
}
 
template <typename container_t, typename T>
container_t pad(container_t container, T value) {
    decltype(container.begin()->size()) maxsize = 0;
    for (const auto& x : container) {
        if (x.size() > maxsize) {
            maxsize = x.size();
        }
    }
    for (auto& x : container) {
        for (auto i = x.size(); i < maxsize; ++i) x.push_back(value);
    }
    return container;
}
 
template <typename T, typename Tuple>
struct tuple_index {
    static const std::size_t value = -1;
    static_assert(!std::is_same<Tuple, std::tuple<>>::value,  // Did you access invalid operators?
                  "Could not get index of type `T` in given `Tuple`");
};
 
template <typename T, typename... Types>
struct tuple_index<T, std::tuple<T, Types...>> {
    static const std::size_t value = 0;  
};
 
template <typename T, typename U, typename... Types>
struct tuple_index<T, std::tuple<U, Types...>> {
    static const std::size_t value = 1 + tuple_index<T, std::tuple<Types...>>::value;
};
 
template <typename T, typename Tuple>
struct tuple_has_type;
 
template <typename T>
struct tuple_has_type<T, std::tuple<>> : std::false_type {};
 
template <typename T, typename U, typename... Ts>
struct tuple_has_type<T, std::tuple<U, Ts...>> : tuple_has_type<T, std::tuple<Ts...>> {};
 
template <typename T, typename... Ts>
struct tuple_has_type<T, std::tuple<T, Ts...>> : std::true_type {};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_UTILS_STDTYPESUTILS_HPP_