eve::callable< Func, OptionsValues, Options > Struct Template Reference

Detailed Description

template<template< typename > class Func, typename OptionsValues, typename... Options>
struct eve::callable< Func, OptionsValues, Options >

CRTP base class defining an EVE's Callable Object.

Defined in Header

#include <eve/traits/overload.hpp>

All EVE Callable Object use a similar protocol to find and call proper architecture or type specific implementation. This protocol includes options checks and management and proper level of error reporting. eve::callable is the most general base class for defining such a Callable Object without having to manually handles all these details.

Template Parameters

Func	Type of current Callable Object being implemented.
OptionsValues	Type of stored options.
Options	List of supported option specifications.

Example

#include <iostream>
#include <type_traits>
#include <eve/traits/overload.hpp>
#include <eve/wide.hpp>
 
namespace eve
{
  template<typename Options>
  struct func_t : callable<func_t, Options>
  {
    // operator() are defined here to maximize quality of error message. They all use EVE_DISPATCH_CALL at some point.
    template<eve::integral_value T>
    EVE_FORCEINLINE T       operator()(T v)       const { return EVE_DISPATCH_CALL(v); }
    EVE_FORCEINLINE double  operator()(double v)  const { return EVE_DISPATCH_CALL(v); }
    EVE_FORCEINLINE void    operator()(float)     const = delete;
 
    // This ties the function object to the overload set
    EVE_CALLABLE_OBJECT(func_t, func_);
  };
 
  // Build the callable object from the function object type
  inline constexpr auto func = functor<func_t>;
};
 
// As func_t used EVE_CALLABLE_OBJECT, we should write overloads in eve::_
namespace eve::_
{
  auto func_(EVE_REQUIRES(cpu_), eve::callable_options auto const&, eve::integral_value auto x) {  return x*x;  }
  auto func_(EVE_REQUIRES(cpu_), eve::callable_options auto const&, double x)                   {  return 1./x; }
}
 
int main()
{
  std::cout << eve::func(8) << "\n";
  std::cout << eve::func(eve::wide<short>{77}) << "\n";
  std::cout << eve::func(25.) << "\n";
 
  std::cout << "Is func(double) supported     : "
            << std::boolalpha << std::is_invocable_v<eve::tag_t<eve::func>, double>
            << "\n";
 
  std::cout << "Is func(float) supported      : "
            << std::boolalpha << std::is_invocable_v<eve::tag_t<eve::func>, float>
            << "\n";
 
  std::cout << "Is func(wide<float>) supported: "
            << std::boolalpha << std::is_invocable_v<eve::tag_t<eve::func>, eve::wide<float>>
            << "\n";
}

Public Member Functions
constexpr auto	operator[] (O o) const
	Adds an option to current callable.
constexpr auto	options () const
	Retrieves the current options' state, including processed default.

Friends
template<template< typename > class F2, typename OV2, typename... O2>
constexpr bool	operator== (callable const &, callable< F2, OV2, O2... > const &)
	Checks if two callable are instances of the same function.

Member Function Documentation

operator[]()

auto eve::decorated_with< OptionsValues, Options >::operator[] ( O o ) const

inlineconstexprinherited

Adds an option to current callable.

If the option o is supported by one of the specifications Spec, build a new Callable Object that will behave as an instance of Tag except the option o is passed inside an eve::options as an additional parameter.

Does not participate in overload resolution if o is not supported by any option specifications.

Parameters

o	Option to add to current's Callable Object setup

Returns

A new Callable Object with the options o set.