smash::detail Namespace Reference

specialize a type for all of the STL containers. More...

Classes
struct	KeyTraits
	Class template to store Key traits outside the Key class, allowing for reuse both in the Key class itself and in helper implementation details. More...
struct	is_stl_container
	Implementation of the type trait to infer if a type is an STL container. More...
struct	is_stl_container< std::vector< Args... > >
	Trait specialization for std::vector. More...
struct	is_stl_container< std::set< Args... > >
	Trait specialization for std::set. More...
struct	is_stl_container< std::map< Args... > >
	Trait specialization for std::map. More...

Functions
template<typename T >
const KeyTraits< T >::validator_type &	get_default_validator () noexcept
	Function template to get a default trivial validator. More...
template<typename T >
constexpr auto	type_name ()
	Get type of variable as string in a human-readable way. More...
template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>
bool	almost_equal_knuthish (const N x, const N y, const N epsilon, const N threshold=N{0.0}) noexcept
	Compare whether two floating-point numbers are approximately equal à la Knuth up to a given tolerance. More...

Detailed Description

specialize a type for all of the STL containers.

Function Documentation

get_default_validator()

template<typename T >

const KeyTraits<T>::validator_type& smash::detail::get_default_validator ( )

noexcept

Function template to get a default trivial validator.

Returns

A const reference to a functor that always returns true .

Attention

It might look unnecessary to have a function returning the functor and you might think that the functor as a constant global variable template would be enough. However, this would be in general wrong because this functor is used in the Key constructors which are used by the InputKeys class, that is a collection of static Keys. Hence, since initialization order of static/global objects in C++ is undefined, we need to to do something else. We use therefore the "construct on first use idiom", making the functor a static object in a function scope. For more information, refer for example to ISO C++ FAQ.

Definition at line 135 of file key.h.

                                                                            {
  static const typename KeyTraits<T>::validator_type always_true =
      [](const T&) noexcept { return true; };
  return always_true;
}

type_name()

template<typename T >

constexpr auto smash::detail::type_name ( )

constexpr

Get type of variable as string in a human-readable way.

Template Parameters

T	The type to be returned.

Returns

A std::string containing the name of the type.

Definition at line 27 of file numeric_cast.h.

                           {
  std::string_view name, prefix, suffix;
#ifdef __clang__
  name = __PRETTY_FUNCTION__;
  prefix = "auto smash::detail::type_name() [T = ";
  suffix = "]";
#elif defined(__GNUC__)
  name = __PRETTY_FUNCTION__;
  prefix = "constexpr auto smash::detail::type_name() [with T = ";
  suffix = "]";
#elif defined(_MSC_VER)
  name = __FUNCSIG__;
  prefix = "auto __cdecl smash::detail::type_name<";
  suffix = ">(void)";
#else
  name = "UNKNOWN";
  prefix = "";
  suffix = "";
#endif
  name.remove_prefix(prefix.size());
  name.remove_suffix(suffix.size());
  return std::string{name};
}

almost_equal_knuthish()

template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>

bool smash::detail::almost_equal_knuthish ( const N  x, const N  y, const N  epsilon, const N  threshold = N{0.0}  )

noexcept

Compare whether two floating-point numbers are approximately equal à la Knuth up to a given tolerance.

On top of Knuth's tolerance predicate some corner cases are treated and the caller can specify a threshold as last parameter to make the test consider numbers equal if the absolute value of their difference is below of it.

Parameters

[in]	x	First of the two numbers.
[in]	y	Second of the two numbers.
[in]	epsilon	The relative tolerance for the test.
[in]	threshold	Threshold for the number comparison. By default this is zero, implying no threshold is considered.

Returns

false if either x or y is not a finite number, provided that the type supports non-numeric representations (i.e. is infinite or NAN);

true if x == y;

true if x == 0 and if \( |x| \le \varepsilon\);

true if y == 0 and if \( |y| \le \varepsilon\);

true if \( |x - y| \le M_\mathrm{threshold} \);

true if \( |x - y| \le \varepsilon \cdot \max(|x|, |y|) \) (Knuth's tolerance predicate);

false otherwise.

Definition at line 59 of file numerics.h.

                                                {0.0}) noexcept {
  assert(epsilon > 0);
  assert(threshold >= 0);
  if constexpr (std::numeric_limits<N>::is_iec559) {
    if (!std::isfinite(x) || !std::isfinite(y)) {
      return false;
    }
  }
  if (x == y)
    return true;
  else if (x == 0)
    return std::abs(y) <= epsilon;
  else if (y == 0)
    return std::abs(x) <= epsilon;
  else
    return std::abs(x - y) <= threshold ||
           std::abs(x - y) <= epsilon * std::max(std::abs(x), std::abs(y));
}