utility.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_DETAIL_UTILITY_HPP_
#define PLSSVM_DETAIL_UTILITY_HPP_
#pragma once
 
#include "plssvm/default_value.hpp"       // plssvm::default_value
#include "plssvm/detail/type_traits.hpp"  // PLSSVM_REQUIRES, plssvm::detail::always_false_v
 
#include <algorithm>                      // std::remove_if, std::find
#include <cstddef>                        // std::size_t
#include <iterator>                       // std::distance
#include <string>                         // std::string
#include <tuple>                          // std::forward_as_tuple, std::get
#include <type_traits>                    // std::underlying_type_t, std::is_enum_v
 
namespace plssvm::detail {
 
[[noreturn]] inline void unreachable() {
    // Uses compiler specific extensions if possible.
    // Even if no extension is used, undefined behavior is still raised by
    // an empty function body and the noreturn attribute.
#if defined(__GNUC__)    // GCC, Clang, ICC
    __builtin_unreachable();
#elif defined(_MSC_VER)  // MSVC
    __assume(false);
#endif
}
 
template <std::size_t I, typename... Types>
[[nodiscard]] constexpr decltype(auto) get(Types &&...args) noexcept {
    static_assert(I < sizeof...(Types), "Out-of-bounce access!: too few elements in parameter pack");
    return std::get<I>(std::forward_as_tuple(args...));
}
 
template <typename Enum>
[[nodiscard]] constexpr std::underlying_type_t<Enum> to_underlying(const Enum e) noexcept {
    static_assert(std::is_enum_v<Enum>, "e must be an enumeration type!");
    return static_cast<std::underlying_type_t<Enum>>(e);
}
 
template <typename Enum>
[[nodiscard]] constexpr std::underlying_type_t<Enum> to_underlying(const default_value<Enum> &e) noexcept {
    static_assert(std::is_enum_v<Enum>, "e must be an enumeration type!");
    return to_underlying(e.value());
}
 
template <typename Container, typename Pred, PLSSVM_REQUIRES(is_container_v<Container>)>
inline typename Container::size_type erase_if(Container &c, Pred pred) {
    if constexpr (is_vector_v<Container>) {
        // use optimized version for std::vector
        auto iter = std::remove_if(c.begin(), c.end(), pred);
        auto dist = std::distance(iter, c.end());
        c.erase(iter, c.end());
        return dist;
    } else {
        // generic version otherwise
        auto old_size = c.size();
        for (auto i = c.begin(), last = c.end(); i != last;) {
            if (pred(*i)) {
                i = c.erase(i);
            } else {
                ++i;
            }
        }
        return old_size - c.size();
    }
}
 
template <typename Container, typename T, PLSSVM_REQUIRES(is_container_v<Container>)>
[[nodiscard]] inline bool contains(const Container &c, const T &val) {
    if constexpr (is_sequence_container_v<Container>) {
        // use std::find for sequence containers
        return std::find(c.cbegin(), c.cend(), val) != c.cend();
    } else {
        // use count otherwise
        return c.count(val) > 0;
    }
}
 
[[nodiscard]] std::string current_date_time();
 
}  // namespace plssvm::detail
 
#endif  // PLSSVM_DETAIL_UTILITY_HPP_