type_traits/is_callable.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser Public License for more details.
//
// You should have received a copy of the GNU Lesser Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef IS_CALLABLE_HH
# define IS_CALLABLE_HH

# include <type_traits>
# include <memory>
# include "try_first.hh"
# include "always_false.hh"
# include "../concept/concept_tools.hh"
# include "../type_traits/identity.hh"

namespace catsfoot {

  template <typename T>
  struct undefined_return {};

  namespace details {
    template <typename T, typename... U>
    std::false_type is_callable_helper(try_second, T&&, U&&...) {
      static_assert(always_false<T>::value,
                    "Cannot use this function");
      return 0;
    }

    template <typename T, typename... U,
              typename =
              decltype(std::declval<T>()(std::declval<U>()...))>
    std::true_type is_callable_helper(try_first, T&&, U&&...) {
      static_assert(always_false<T>::value,
                    "Cannot use this function");
      return 0;
    }

    template <typename T>
    struct callable_real_map {};

    template <typename T>
    struct callable_bad_map {};

    template <typename T, typename... U>
    struct callable_real_map<T(U...)> {
      typedef decltype(std::declval<T>()(std::declval<U>()...))
      result_type;
    };

    template <typename T, typename... U>
    struct callable_bad_map<T(U...)> {
      typedef undefined_return<T(U...)> result_type;
    };
  }

  template <typename T>
  struct is_callable
#ifndef DOC_GEN
    : public is_callable<T()>
#endif
  {
  };

  template <typename T, typename... U>
  struct is_callable<T(U...)>:
    public identity<decltype(details::
                             is_callable_helper(details::try_first(),
                                                std::declval<T>(),
                                                std::declval<U>()...))>
  ::type {
    typedef decltype(details::
                     is_callable_helper(details::try_first(),
                                        std::declval<T>(),
                                        std::declval<U>()...))
    super;
    typedef typename
    std::conditional<super::value,
                     details::callable_real_map<T(U...)>,
                     details::callable_bad_map<T(U...)> >::type::result_type
    result_type;
  };

  template <typename... U>
  struct is_callable<void(U...)>:
    public std::false_type {
    typedef undefined_return<void(U...)> result_type;
  };
}

#endif