functional.h

#ifndef ADIAR_FUNCTIONAL_H
#define ADIAR_FUNCTIONAL_H
 
#include <functional>
#include <limits>
 
#include <adiar/exception.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](const ValueType& x) { *(iter++) = x; };
  }
 
  template <typename ValueType, typename OutputIt>
  inline consumer<ValueType>
  make_consumer(OutputIt&& iter)
  {
    return [_iter = std::move(iter)](const ValueType& x) mutable { *(_iter++) = x; };
  }
 
  template <typename OutputIt>
  inline consumer<typename OutputIt::container_type::value_type>
  make_consumer(OutputIt& iter)
  {
    using value_type = typename OutputIt::container_type::value_type;
 
    return [&iter](const value_type& x) { *(iter++) = x; };
  }
 
  template <typename OutputIt>
  inline consumer<typename OutputIt::container_type::value_type>
  make_consumer(OutputIt&& iter)
  {
    using value_type = typename OutputIt::container_type::value_type;
 
    return [_iter = std::move(iter)](const value_type& x) mutable { *(_iter++) = x; };
  }
 
  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 ForwardIt::value_type>
  make_consumer(ForwardIt&& begin, ForwardIt&& end)
  {
    using value_type = typename ForwardIt::value_type;
 
    return [_begin = std::move(begin), _end = std::move(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 ForwardIt::value_type>
  make_generator(ForwardIt& begin, ForwardIt& end)
  {
    using value_type = typename ForwardIt::value_type;
 
    return [&begin, &end]() -> optional<value_type> {
      if (begin == end) { return {}; }
      return *(begin++);
    };
  }
 
  template <typename ForwardIt>
  inline generator<typename ForwardIt::value_type>
  make_generator(ForwardIt&& begin, ForwardIt&& end)
  {
    using value_type = typename ForwardIt::value_type;
 
    return [_begin = std::move(begin), _end = std::move(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