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

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