function.hpp

Go to the documentation of this file.

/*
  FUNCTION.hpp  -  metaprogramming utilities for transforming function types

   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef LIB_META_FUNCTION_H
#define LIB_META_FUNCTION_H

#include "lib/meta/typelist.hpp"
#include "lib/meta/util.hpp"

#include <functional>



namespace lib {
namespace meta{

  using std::function;
  
  
  template<typename FUN, typename SEL =void>
  struct _Fun
    : std::false_type
    {
      using Functor = FUN;
    };
  
  template<typename FUN>
  struct _Fun<FUN,  enable_if<has_FunctionOperator<FUN>> >
    : _Fun<decltype(&FUN::operator())>
    {
      using Functor = FUN;
    };
  
  template<typename RET, typename...ARGS>
  struct _Fun<RET(ARGS...)>
    : std::true_type
    {
      using Ret  = RET;
      using Args = Types<ARGS...>;
      using Sig  = RET(ARGS...);
      using Functor = std::function<Sig>;
      enum { ARITY = sizeof...(ARGS) };
    };
  
  template<typename RET, typename...ARGS>
  struct _Fun<RET(ARGS...) noexcept>
    : _Fun<RET(ARGS...)>
    { };
  
  template<typename SIG>
  struct _Fun<SIG*>
    : _Fun<SIG>
    { };
  
  template<typename SIG>
  struct _Fun<SIG const&>
    : _Fun<SIG>
    { };
  
  template<typename SIG>
  struct _Fun<SIG&>
    : _Fun<SIG>
    { };
  
  template<typename SIG>
  struct _Fun<SIG&&>
    : _Fun<SIG>
    { };
  
  template<class C, typename RET, typename...ARGS>
  struct _Fun<RET (C::*) (ARGS...)>
    : _Fun<RET(ARGS...)>
    { };
  
  template<class C, typename RET, typename...ARGS>
  struct _Fun<RET (C::*) (ARGS...) noexcept>
    : _Fun<RET(ARGS...)>
    { };
  
  template<class C, typename RET, typename...ARGS>
  struct _Fun<RET (C::*) (ARGS...)  const>
    : _Fun<RET(ARGS...)>
    { };
  
  template<class C, typename FUN>
  struct _Fun<FUN (C::*)>
    : _Fun<FUN>
    { };
  
  
  
  
  
  template<typename FUN>
  using _FunRet = typename _Fun<FUN>::Ret;
  
  namespace {
    template<typename FUN>
    struct _DetectSingleArgFunction
      {
        static_assert(_Fun<FUN>()           , "something funktion-like required");
        static_assert(_Fun<FUN>::ARITY == 1 , "function with exactly one argument required");
        
        using Sig = typename _Fun<FUN>::Sig;
        using Arg = typename _Fun<Sig>::Args::List::Head;
      };
  }
  
  template<typename FUN>
  using _FunArg = typename _DetectSingleArgFunction<FUN>::Arg;
  
  
  
  template<typename FUN, uint a>
  using has_Arity = std::bool_constant<_Fun<FUN>::ARITY == a>;
  
  template<typename FUN>
  using is_NullaryFun = has_Arity<FUN,0>;
  
  template<typename FUN>
  using is_UnaryFun  = has_Arity<FUN,1>;
  
  template<typename FUN>
  using is_BinaryFun = has_Arity<FUN,2>;
  
  
  
  
  
  template<typename FUN, typename SIG,  bool =_Fun<FUN>()>
  struct has_Sig
    : std::is_same<SIG, typename _Fun<FUN>::Sig>
    { };
  
  template<typename FUN, typename X>
  struct has_Sig<FUN,X, false>
    : std::false_type
    { };
  
#define ASSERT_VALID_SIGNATURE(_FUN_, _SIG_) \
        static_assert (lib::meta::has_Sig<_FUN_, _SIG_>::value, \
                       "Function " STRINGIFY(_FUN_) " unsuitable, expected signature: " STRINGIFY(_SIG_));
  
  
  
  template<typename SIG, typename FUN>
  constexpr inline auto
  isFunMember (FUN)
  {
    return has_Sig<FUN,SIG>{};
  }
  
#define ASSERT_MEMBER_FUNCTOR(_EXPR_, _SIG_) \
        static_assert (lib::meta::isFunMember<_SIG_>(_EXPR_), \
                       "Member " STRINGIFY(_EXPR_) " unsuitable, expect function signature: " STRINGIFY(_SIG_));
  
  
  
  
  
  
  template<class TAR>
  struct InstancePlaceholder { };
  
  namespace {// Helper to inject instance-pointer instead of placeholder...
    template<class W, class TAR>
    constexpr inline TAR*
    maybeInject (W& instance, InstancePlaceholder<TAR>)
    {
      return static_cast<TAR*> (&instance);
    }
    
    template<class W, typename X>
    constexpr inline X
    maybeInject (W&, X&& x)
    {
      return std::move(x);
    }
  }//(End)Helper for lateBindInstance.

  template<class W, class TUP>
  constexpr inline auto
  lateBindInstance (W& instance, TUP&& invocation)
  {
    auto splice = [&instance](auto&& ...xs)
                    {
                      return std::tuple{maybeInject (instance, std::move(xs))...};
                    };
    return std::apply (splice, std::forward<TUP> (invocation));
  }
  
  
  
  
  
  
                                    
  template<typename RET, typename ARGS>
  struct BuildFunType;
  
  
  template< typename RET>
  struct BuildFunType<RET, Types<> >
  {
    using Sig = RET(void);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          >
  struct BuildFunType<RET, Types<A1>>
  {
    using Sig = RET(A1);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          >
  struct BuildFunType<RET, Types<A1,A2>>
  {
    using Sig = RET(A1,A2);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          >
  struct BuildFunType<RET, Types<A1,A2,A3>>
  {
    using Sig = RET(A1,A2,A3);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          , typename A4
          >
  struct BuildFunType<RET, Types<A1,A2,A3,A4>>
  {
    using Sig = RET(A1,A2,A3,A4);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          , typename A4
          , typename A5
          >
  struct BuildFunType<RET, Types<A1,A2,A3,A4,A5>>
  {
    using Sig = RET(A1,A2,A3,A4,A5);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          , typename A4
          , typename A5
          , typename A6
          >
  struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6>>
  {
    using Sig = RET(A1,A2,A3,A4,A5,A6);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          , typename A4
          , typename A5
          , typename A6
          , typename A7
          >
  struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6,A7>>
  {
    using Sig = RET(A1,A2,A3,A4,A5,A6,A7);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          , typename A4
          , typename A5
          , typename A6
          , typename A7
          , typename A8
          >
  struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8>>
  {
    using Sig = RET(A1,A2,A3,A4,A5,A6,A7,A8);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  template< typename RET
          , typename A1
          , typename A2
          , typename A3
          , typename A4
          , typename A5
          , typename A6
          , typename A7
          , typename A8
          , typename A9
          >
  struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8,A9>>
  {
    using Sig = RET(A1,A2,A3,A4,A5,A6,A7,A8,A9);
    using Fun = _Fun<Sig>;
    using Func = function<Sig>;
    using Functor = Func;
  };
  
  
  
  
  
}} // namespace lib::meta
#endif