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

CRTP base class giving an EVE's Callable Object the constant function semantic. More...

#include <eve/traits/overload/impl/constant.hpp>

Detailed Description

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

Defined in Header

#include <eve/traits/overload.hpp>

Constants functions in EVE are built using a very common pattern. Inheriting from eve::constant_callable simplifies the implementation of such eve::callable by just requiring your eve::callable type to implement a static value member function that provides the constant value using two parameters:

• an eve::options pack containing potential decorators passed to the constant.
• an eve::as instance to specify the translated element type of the output.

Constant functions in EVE also supports masking, which is directly implemented in eve::constant_callable.

Note

The deferred overload named in the EVE_CALLABLE_OBJECT macro process is still available if an architecture specific implementation of any given constant is required.

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
{
  // Constant generations functions have a precise behavior so they can be defined using the
  // constant_callable scaffolding that enables this.
  // Note that constant_callable provides support for conditional out of the box.
  template<typename Options>
  struct some_pi_t : constant_callable<some_pi_t, Options>
  {
    // A constant must provide a value() static member with up to two parameters:
    //  * an eve::as instance to specify the output type
    //  * an optional eve::options containing potential decorators passed to the constant
    template<typename T>
    static EVE_FORCEINLINE T value(eve::as<T> const&, auto) { return static_cast<T>(3.14159216); }
 
    // Supported function calls are still required
    template<eve::floating_value T>
    EVE_FORCEINLINE T    operator()(as<T>    v) const { return EVE_DISPATCH_CALL(v); }
 
    // Complete the callable interface.
    EVE_CALLABLE_OBJECT(some_pi_t, some_pi_);
  };
 
  inline constexpr auto some_pi = functor<some_pi_t>;
};
 
int main()
{
  std::cout << eve::some_pi(eve::as(1.0)) << "\n";
  std::cout << eve::some_pi(eve::as<eve::wide<float>>{}) << "\n";
  std::cout << eve::some_pi[eve::keep_between(1,3)](eve::as<eve::wide<float>>{}) << "\n";
  std::cout << eve::some_pi[eve::keep_between(1,3).else_(99)](eve::as<eve::wide<float>>{}) << "\n\n";
 
  std::cout << "Is Pi(as<float>) supported: "
            << std::boolalpha << std::is_invocable_v<eve::tag_t<eve::some_pi>, eve::as<float>>
            << "\n";
 
  std::cout << "Is Pi(float) supported: "
            << std::boolalpha << std::is_invocable_v<eve::tag_t<eve::some_pi>, float>
            << "\n";
 
  std::cout << "Is Pi(as<wide<unsigned char>>) supported: "
            << std::boolalpha << std::is_invocable_v<eve::tag_t<eve::some_pi>, eve::as<eve::wide<unsigned char>>>
            << "\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.