FunctorHolder.h

 
#pragma once
 
#if defined(FunctorHolder_RECURSES)
#error Recursive header files inclusion detected in FunctorHolder.h
#else // defined(FunctorHolder_RECURSES)
#define FunctorHolder_RECURSES
 
#if !defined FunctorHolder_h
#define FunctorHolder_h
 
// Inclusions
#include <iostream>
#include <type_traits>
#include <functional>
#include <memory>
 
namespace DGtal
{
namespace functors
{
 
// Implementation details
namespace
{
 
  template <bool>
  struct Invoker
  {
    template <typename F, typename... T>
    static inline
    auto apply(F && fn, T &&... args)
        -> decltype((std::forward<F>(fn))(std::forward<T>(args)...))
      {
        return (std::forward<F>(fn))(std::forward<T>(args)...);
      }
  };
 
  template <>
  struct Invoker<true>
  {
    template <typename F, typename... T>
    static inline
    auto apply(F && fn, T &&... args)
        -> decltype((*std::forward<F>(fn))(std::forward<T>(args)...))
      {
        return (*std::forward<F>(fn))(std::forward<T>(args)...);
      }
  };
 
  struct SharedPtrTrait
    {
      template <typename T>
      static constexpr std::true_type   apply(std::shared_ptr<T> const&) { return {}; }
 
      template <typename T>
      static constexpr std::false_type  apply(T const&) { return {}; }
    };
 
  struct ReferenceWrapperTrait
    {
      template <typename T>
      static constexpr std::true_type   apply(std::reference_wrapper<T> const&) { return {}; }
 
      template <typename T>
      static constexpr std::false_type  apply(T const&) { return {}; }
    };
 
} // anonymous namespace
 
 
// class FunctorHolder
template <
  typename FunctorStorage,
  bool NeedDereference
>
class FunctorHolder
{
  // ------------------------- Private Datas --------------------------------
private:
 
  FunctorStorage myFunctor; 
 
  // ----------------------- Standard services ------------------------------
public:
 
  template <
    typename Function,
    // SFINAE trick to disable this constructor in a copy/move construction context.
    typename std::enable_if<!std::is_base_of<FunctorHolder, typename std::decay<Function>::type>::value, int>::type = 0
  >
  explicit FunctorHolder(Function && fn)
      : myFunctor(std::forward<Function>(fn))
  {
  }
 
  // ----------------------- Interface --------------------------------------
public:
 
  template <typename... T>
  inline auto operator() (T &&... args) const
      -> decltype(Invoker<NeedDereference>::apply(this->myFunctor, std::forward<T>(args)...))
    {
      return Invoker<NeedDereference>::apply(myFunctor, std::forward<T>(args)...);
    }
 
  template <typename... T>
  inline auto operator() (T &&... args)
      -> decltype(Invoker<NeedDereference>::apply(this->myFunctor, std::forward<T>(args)...))
    {
      return Invoker<NeedDereference>::apply(myFunctor, std::forward<T>(args)...);
    }
 
  inline
  void selfDisplay ( std::ostream & out ) const
    {
      out << "[FunctorHolder]";
      if ( SharedPtrTrait::apply(myFunctor) )
        out << " using std::shared_ptr storage (rvalue)";
      else if ( ReferenceWrapperTrait::apply(myFunctor) )
        out << " using std::reference_wrapper storage (lvalue)";
      else
        out << " using custom storage";
    }
 
  inline constexpr
  bool isValid() const
    {
      return true;
    }
}; // End of class FunctorHolder
 
template <typename FunctorStorage, bool NeedDereference>
std::ostream&
operator<< ( std::ostream & out, const FunctorHolder<FunctorStorage, NeedDereference> & object )
{
  object.selfDisplay( out );
  return out;
}
 
// Implementation details
namespace {
 
  template <typename Function>
  inline auto holdFunctorImpl(Function && fn, std::true_type)
      -> FunctorHolder<decltype(std::ref(std::forward<Function>(fn))), false>
    {
      return FunctorHolder<decltype(std::ref(std::forward<Function>(fn))), false>{ std::forward<Function>(fn) };
    }
 
  template <typename Function>
  inline auto holdFunctorImpl(Function && fn, std::false_type)
      -> FunctorHolder<std::shared_ptr<Function>, true>
  {
      return FunctorHolder<std::shared_ptr<Function>, true>{ std::make_shared<Function>(std::forward<Function>(fn)) };
  }
 
} // anonymous namespace
 
 
// FunctorHolder construction helper
template <typename Function>
inline auto holdFunctor(Function && fn)
  -> decltype(holdFunctorImpl(std::forward<Function>(fn), typename std::is_lvalue_reference<Function>{})) // Can we please pass to C++14 ?
{
  return holdFunctorImpl(std::forward<Function>(fn), typename std::is_lvalue_reference<Function>{});
}
 
} // namespace functors
} // namespace DGtal
 
#endif // !defined FunctorHolder_h
 
#undef FunctorHolder_RECURSES
#endif // else defined(FunctorHolder_RECURSES)