checked_conversions.h

Go to the documentation of this file.

// === checked_conversions.h ===========================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_BASE_CHECKED_CONVERSIONS_H
#define SEN_CORE_BASE_CHECKED_CONVERSIONS_H
 
// sen
#include "sen/core/base/assert.h"
#include "sen/core/base/integer_compare.h"
#include "sen/core/base/numbers.h"
 
// std
#include <cassert>
#include <cmath>
#include <limits>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace sen::std_util
{

void reportToStandardError(std::string_view message);
 
struct ReportPolicyAssertion
{
  static void report(const std::string_view message)
  {
    reportToStandardError(message);
    SEN_ASSERT(false);
  }
};
 
struct ReportPolicyTrace
{
  static void report(std::string_view message) { trace(std::string(message)); }
};
 
struct ReportPolicyLog
{
  static void report(std::string_view message);
};
 
struct ReportPolicyIgnore
{
  static void report(std::string_view message) { std::ignore = message; }
};

struct ReportPolicyThrow
{
  static void report(std::string_view message) { throwRuntimeError(std::string(message)); }
};
 
namespace impl
{
template <typename ToType, typename FromType, typename ReportPolicy = ReportPolicyIgnore>
ToType conversionImpl(FromType from)
{
  if constexpr (std::is_same_v<ToType, bool>)
  {
    return static_cast<bool>(from);
  }
  else if constexpr (std::is_floating_point_v<ToType> || std::is_floating_point_v<FromType>)
  {
    if constexpr (std::is_same_v<FromType, ToType>)
    {
      return from;
    }
    else
    {
      // NaN compares false against every bound, so it reaches the cast below,
      // where converting it to an integer is undefined. A floating-point target
      // is left alone: there the cast is defined and NaN is worth keeping.
      if constexpr (!std::is_floating_point_v<ToType>)
      {
        if (std::isnan(static_cast<float64_t>(from)))
        {
          ReportPolicy::report("the value is not a number");
          return ToType {};
        }
      }
 
      if (std::isless(static_cast<float64_t>(from), static_cast<float64_t>(std::numeric_limits<ToType>::lowest())))
      {
        ReportPolicy::report("the value is too small for the target type");
        return std::numeric_limits<ToType>::lowest();
      }
 
      if (std::isgreater(static_cast<float64_t>(from), static_cast<float64_t>(std::numeric_limits<ToType>::max())))
      {
        ReportPolicy::report("the value is too large for the target type");
        return std::numeric_limits<ToType>::max();
      }
 
      return static_cast<ToType>(from);
    }
  }
  else
  {
    if (sen::std_util::cmp_less(from, std::numeric_limits<ToType>::lowest()))
    {
      ReportPolicy::report("the value is too small for the target type");
      return std::numeric_limits<ToType>::lowest();
    }
 
    if (sen::std_util::cmp_greater(from, std::numeric_limits<ToType>::max()))
    {
      ReportPolicy::report("the value is too large for the target type");
      return std::numeric_limits<ToType>::max();
    }
 
    return static_cast<ToType>(from);
  }
}
 
}  // namespace impl

template <typename ToType, typename ReportPolicy = ReportPolicyAssertion, typename FromType>
[[nodiscard]] ToType checkedConversion(FromType from)
{
  return impl::conversionImpl<ToType, FromType, ReportPolicy>(from);
}

template <typename ToType, typename ReportPolicy = ReportPolicyIgnore, typename FromType>
[[nodiscard]] ToType ignoredLossyConversion(FromType from)
{
  return impl::conversionImpl<ToType, FromType, ReportPolicy>(from);
}
 
}  // namespace sen::std_util
 
#endif  // SEN_CORE_BASE_CHECKED_CONVERSIONS_H