algorithm.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <future>
#include <string>
#include <type_traits>
#include <vector>
 
#include "bricks/detail/contains.hpp"
#include "bricks/detail/index_of.hpp"
 
namespace bricks {
 
template <class Container>
auto keys(const Container& input_map) -> std::vector<typename Container::key_type>
{
  std::vector<typename Container::key_type> retval;
  retval.reserve(input_map.size());
  std::transform(std::begin(input_map), std::end(input_map), std::back_inserter(retval),
                 [](auto&& pair) { return std::get<0>(std::forward<decltype(pair)>(pair)); });
 
  return retval;
}
 
template <class Container>
auto values(const Container& input_map) -> std::vector<typename Container::mapped_type>
{
  std::vector<typename Container::mapped_type> retval;
  retval.reserve(input_map.size());
  std::transform(std::begin(input_map), std::end(input_map), std::back_inserter(retval),
                 [](auto&& pair) { return std::get<1>(std::forward<decltype(pair)>(pair)); });
 
  return retval;
}
 
template <typename F, typename... FrontArgs>
constexpr auto bind_front(F&& f, FrontArgs&&... front_args)
{
  // front_args are copied because multiple invocations of this closure are possible
  return [captured_f = std::forward<F>(f), front_args...](auto&&... back_args) {
    return std::invoke(captured_f, front_args..., std::forward<decltype(back_args)>(back_args)...);
  };
}
 
template <class Container, class Value>
constexpr auto contains(const Container& container, const Value& value) noexcept -> bool
{
  return detail::contains(container, value);
}
 
template <class Container, class UnaryPredicate>
constexpr auto contains_if(const Container& container, const UnaryPredicate& predicate) -> bool
{
  return std::find_if(std::begin(container), std::end(container), predicate) != std::end(container);
}
 
template <class Container, class Value>
constexpr auto index_of(const Container& container, const Value& value) noexcept
    -> std::optional<size_t>
{
  return detail::index_of(container, value);
}
 
template <class Container, class UnaryPredicate>
constexpr auto index_of_if(const Container& container, const UnaryPredicate& predicate)
    -> std::optional<size_t>
{
  const auto it = std::find_if(std::begin(container), std::end(container), predicate);
  return it != std::end(container) ? std::make_optional(std::distance(std::begin(container), it))
                                   : std::nullopt;
}
 
template <class T, class Rep, class Period>
auto is_ready_after(const std::future<T>& future,
                    const std::chrono::duration<Rep, Period>& timeout) noexcept -> bool
{
  return future.wait_for(timeout) == std::future_status::ready;
}
 
template <class T, class Clock, class Duration>
auto is_ready_at(const std::future<T>& future,
                 const std::chrono::time_point<Clock, Duration>& timeout) noexcept -> bool
{
  return future.wait_until(timeout) == std::future_status::ready;
}
 
}  // namespace bricks