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

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

#pragma once

#include <utility>

namespace stream::detail {
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::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>
constexpr bool is_dereferencable_v = is_dereferencable<T>{};

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;
}