is_call_possible.h

Go to the documentation of this file.

/*
 * is_call_possible.h
 *
 *  Created on: Jul 14, 2014
 *      Author: josh
 */

#ifndef IS_CALL_POSSIBLE_H_
#define IS_CALL_POSSIBLE_H_

namespace kw {

template<typename Type>
class has_member {
  class yes {
    char m;
  };

  class no {
    yes m[2];
  };

  struct DummyFnCallOperator {
    void operator()() {}
  };

  struct HasAtLeastOneFnCallOperator :
      public Type,
      public DummyFnCallOperator {
  };

  template<typename T, T t>
  class Helper {};

  template<typename U>
  static no deduce(
      U*, Helper<void (DummyFnCallOperator::*)(), &U::operator()>* = 0);

  static yes deduce(...);

 public:
  static const bool result =
      sizeof(yes) == sizeof(deduce((HasAtLeastOneFnCallOperator*) (0)));
};


namespace details {

// If the operator matching the desired inputs returns void, then when
// we take a void expression and comma-operator it with one of these guys,
// the result will be one of these guys. This will lead to the overload
// resolution of a function taking this type as a parameter
template<typename type>
class void_exp_result {};

template<typename type, typename U>
U const& operator,(U const&, void_exp_result<type>);

template<typename type, typename U>
U& operator,(U&, void_exp_result<type>);

template<typename src_type, typename dest_type>
struct clone_constness {
  typedef dest_type type;
};

template<typename src_type, typename dest_type>
struct clone_constness<const src_type, dest_type> {
  typedef const dest_type type;
};

}  // namespace details


template <typename type, typename call_details>
struct is_call_possible
{
private:
  class yes {};
  class no {
    yes m[2];
  };

  struct derived : public type {
    using type::operator();
    no operator()(...) const;
  };

  typedef typename details::clone_constness<type, derived>::type derived_type;

  template<typename T, typename DesiredReturnType>
  struct return_value_check {
    // This overload will be resolved by the compiler if the function
    // call operator matching the desired inputs returns anything that is
    // convertable to `DesiredReturnType`.
    static yes deduce(DesiredReturnType);

    // If the operator matching the desired input arguments returns anything
    // other than void which is not convertable to a DesiredReturnType, then
    // this is the overload that will be resolved by the compiler.
    static no deduce(...);

    // If no operator matching the desired input arguments is found, then
    // the operator() from derived that returns `no` will be the one that
    // get's resolved below.
    static no deduce(no);

    // If the operator matching the desired inputs returns void, then when
    // we take a void expression and comma-operator it with one of
    static no deduce(details::void_exp_result<type>);
  };

  template<typename T>
  struct return_value_check<T, void> {
    static yes deduce(...);
    static no deduce(no);
  };

  template <typename Mid, typename... Tail>
  struct Dispatcher {
    template <typename... Head>
    static inline auto Dispatch( Head ... head)
      -> decltype(Dispatcher<Tail...>::Dispatch(head..., (*(Mid*)0))) {
      Dispatcher<Tail...>::Dispatch(head..., (*(Mid*) 0));
    }
  };

  template <typename Tail>
  struct Dispatcher<Tail> {
    template <typename... Head>
    static inline auto Dispatch(Head... head)
      -> decltype(((derived_type*) 0)->operator()(head..., (*(Tail*)0))){
      ((derived_type*) 0)->operator()(head..., (*(Tail*)0));
    }
  };

  template<bool HasFnCallOperator, typename F>
  struct impl {
    static const bool value = false;
  };

  template<typename... args, typename r>
  struct impl<true, r(args...)> {
    typedef Dispatcher<args...> CallDispatcher;
    // The thing we're taking the `sizeof` here is a function call, so the
    // `sizeof` call will evaluate to the `sizeof` the function's return type.
    //
    // The function being called is the deduce method of
    // `return_value_check<type,r>`. The method resolved by this call will
    // be the one that returns a `yes` object only if the parameter of
    // `deduce()` is compatible with `r`.
    //
    // The parameter of `deduce` is a comma separated tuple of the return
    // type of the function call operator and a `void_exp_result` object. If
    // the function call operator returns void then this tuple resolves to
    // be just the latter argument. Otherwise, the comma operator overload above
    // passes through the return value of the function call operator.
    static const bool value = sizeof(return_value_check<type, r>::deduce(
        (CallDispatcher::Dispatch(), details::void_exp_result<
            type>()))) == sizeof(yes);
  };

  // specializations of impl for 2 args, 3 args,..
 public:
  static const bool value = impl<has_member<type>::result, call_details>::value;
};

template <typename SourceType, typename TargetType>
struct CanConvertTo
{
private:
  class Yes { char x; };
  class No {
    Yes m[2];
  };

  // if SourceType is convertable to TargetType then this overload will be
  // resolved when we call Deduce(SourceType)
  static Yes Deduce(TargetType);

  // If it is not convertible, then this overload will be resolved.
  static No  Deduce(...);

public:
  static constexpr bool value = sizeof(Deduce(*(SourceType*)0)) == sizeof(Yes);
};





}  // namespace kw



#endif /* IS_CALL_POSSIBLE_H_ */