functional.h

#ifndef ADIAR_FUNCTIONAL_H
#define ADIAR_FUNCTIONAL_H
 
#include <functional>
#include <iterator>
#include <limits>
#include <type_traits>
 
#include <adiar/exception.h>
#include <adiar/type_traits.h>
#include <adiar/types.h>
 
 
namespace adiar
{
 
 
  template <typename TypeSignature>
  using function = std::function<TypeSignature>;
 
  template <typename... Args>
  using predicate = function<bool(Args...)>;
 
  template <typename Arg>
  using consumer = function<void(Arg)>;
 
  template <typename ValueType, typename OutputIt>
  inline consumer<ValueType>
  make_consumer(OutputIt&& iter)
  {
    return [_iter = std::forward<OutputIt>(iter)](const ValueType& x) mutable { *(_iter++) = x; };
  }
 
  template <typename OutputIt,
            typename = enable_if<
              !is_void<typename std::iterator_traits<std::remove_reference_t<OutputIt>>::value_type>
              >>
  inline consumer<typename std::iterator_traits<std::remove_reference_t<OutputIt>>::value_type>
  make_consumer(OutputIt&& iter)
  {
    using value_type = typename std::iterator_traits<std::remove_reference_t<OutputIt>>::value_type;
    return make_consumer<value_type, OutputIt>(std::forward<OutputIt>(iter));
  }
 
  template <typename OutputIt,
            typename = enable_if<
              is_void<typename std::iterator_traits<std::remove_reference_t<OutputIt>>::value_type>
            >>
  inline consumer<typename std::remove_reference_t<OutputIt>::container_type::value_type>
  make_consumer(OutputIt&& iter)
  {
    using value_type = typename std::remove_reference_t<OutputIt>::container_type::value_type;
    return make_consumer<value_type, OutputIt>(std::forward<OutputIt>(iter));
  }
 
  template <typename ForwardIt>
  inline consumer<typename ForwardIt::value_type>
  make_consumer(ForwardIt& begin, ForwardIt& end)
  {
    using value_type = typename ForwardIt::value_type;
 
    return [&begin, &end](const value_type& x) {
      if (begin == end) {
        throw out_of_range("Iterator range unable to contain all generated values");
      }
      *(begin++) = x;
    };
  }
 
  template <typename ForwardIt>
  inline consumer<typename std::iterator_traits<std::remove_reference_t<ForwardIt>>::value_type>
  make_consumer(ForwardIt&& begin, ForwardIt&& end)
  {
    using value_type =
      typename std::iterator_traits<std::remove_reference_t<ForwardIt>>::value_type;
 
    return [_begin = std::forward<ForwardIt>(begin),
            _end   = std::forward<ForwardIt>(end)](const value_type& x) mutable {
      if (_begin == _end) {
        throw out_of_range("Iterator range unable to contain all generated values");
      }
      *(_begin++) = x;
    };
  }
 
  template <typename VarType>
  using cost = function<double(VarType)>;
 
  template <typename RetType>
  using generator = function<optional<RetType>()>;
 
  template <typename ForwardIt>
  inline generator<typename std::remove_reference_t<ForwardIt>::value_type>
  make_generator(ForwardIt&& begin, ForwardIt&& end)
  {
    using value_type = typename std::remove_reference_t<ForwardIt>::value_type;
 
    return [_begin = std::forward<ForwardIt>(begin),
            _end   = std::forward<ForwardIt>(end)]() mutable -> optional<value_type> {
      if (_begin == _end) { return {}; }
      return *(_begin++);
    };
  }
 
  template <typename Stream>
  inline generator<typename Stream::value_type>
  make_generator(Stream& s)
  {
    using value_type = typename Stream::value_type;
 
    return [&s]() -> optional<value_type> {
      if (!s.can_pull()) { return {}; }
      return s.pull();
    };
  }
 
  template <typename RetType>
  inline generator<RetType>
  make_generator(const RetType& r)
  {
    return [=, _end = false]() mutable -> optional<RetType> {
      if (_end) { return {}; }
 
      _end = true;
      return r;
    };
  }
 
 
}
 
#endif // ADIAR_FUNCTIONAL_H