cpp-lazy-stream/include/stream/streams/traits.hpp

//
//  traits.hpp
//  stream
//
//  Created by Sam Jaffe on 6/24/17.
//

#pragma once

#include <utility>

namespace stream { namespace detail {
  template <typename T> struct ref_or_val {
    ref_or_val operator=(T && val) {
      value = std::move(val);
      return *this;
    }
    operator T const &() const { return value; }
    T value;
  };

  template <typename T> struct ref_or_val<T &> {
    ref_or_val operator=(T & val) {
      value = &val;
      return *this;
    }
    operator T &() const { return *value; }
    T * value;
  };

  template <typename F> struct map_member_object;
  template <typename T, typename R> struct map_member_object<R T::*> {
    using type = R const &;
    type operator()(T const & val) const { return val.*mem; }
    R T::*mem;
  };

  template <typename F> struct map_member_function;
  template <typename T, typename R>
  struct map_member_function<R (T::*)() const> {
    using type = R;
    type operator()(T const & val) const { return (val.*mem)(); }
    R (T::*mem)() const;
  };

  template <typename F> struct map_member_function;
  template <typename T, typename R>
  struct map_member_function<R (T::*)() const noexcept> {
    using type = R;
    type operator()(T const & val) const noexcept { return (val.*mem)(); }
    R (T::*mem)() const;
  };
}}

namespace stream { namespace traits {
  template <typename F>
  using memvar_f = typename detail::map_member_object<F>::type;
  template <typename F>
  using memfun_f = typename detail::map_member_function<F>::type;

  template <typename F>
  using is_memvar_t =
      typename std::enable_if<std::is_member_object_pointer<F>::value>::type;
  template <typename F>
  using is_memfun_t =
      typename std::enable_if<std::is_member_function_pointer<F>::value>::type;

  template <typename T, typename = void>
  struct is_dereferencable : public std::false_type {};

  template <> struct is_dereferencable<void *> : public std::false_type {};

  template <typename T>
  struct is_dereferencable<T, typename std::enable_if<!std::is_void<
                                  decltype(*std::declval<T>())>::value>::type>
      : public std::true_type {};

  template <typename T, typename F>
  using mapped_t = decltype(std::declval<F>()(std::declval<T>()));

  template <typename T, typename F>
  using fmapped_t =
      typename decltype(std::declval<F>()(std::declval<T>()))::value_type;
}}