safe_cast.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 3 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The Piranha library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_SAFE_CAST_HPP
#define PIRANHA_SAFE_CAST_HPP

#include <boost/numeric/conversion/cast.hpp>
#include <cmath>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>

#include <piranha/detail/demangle.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{


struct safe_cast_failure final : std::invalid_argument {
    using std::invalid_argument::invalid_argument;
};


template <typename To, typename From, typename = void>
struct safe_cast_impl {
private:
    template <typename T>
    using enabler
        = enable_if_t<conjunction<std::is_same<To, T>, std::is_same<From, T>, std::is_copy_constructible<T>>::value,
                      int>;

public:

    template <typename T, enabler<T> = 0>
    To operator()(const T &f) const
    {
        return f;
    }
};

inline namespace impl
{

template <typename To, typename From>
using sc_int_int_enabler = enable_if_t<conjunction<std::is_integral<To>, std::is_integral<From>>::value>;
}


template <typename To, typename From>
struct safe_cast_impl<To, From, sc_int_int_enabler<To, From>> {

    To operator()(const From &f) const
    {
        try {
            return boost::numeric_cast<To>(f);
        } catch (...) {
            piranha_throw(safe_cast_failure, "the integral value " + std::to_string(f)
                                                 + " cannot be converted to the type '" + detail::demangle<To>()
                                                 + "', as the conversion cannot preserve the original value");
        }
    }
};

inline namespace impl
{

template <typename To, typename From>
using sc_float_to_int_enabler = enable_if_t<conjunction<std::is_integral<To>, std::is_floating_point<From>>::value>;
}


template <typename To, typename From>
struct safe_cast_impl<To, From, sc_float_to_int_enabler<To, From>> {

    To operator()(const From &f) const
    {
        if (unlikely(!std::isfinite(f))) {
            piranha_throw(safe_cast_failure, "the non-finite floating-point value " + std::to_string(f)
                                                 + " cannot be converted to the integral type '"
                                                 + detail::demangle<To>() + "'");
        }
        if (std::trunc(f) != f) {
            piranha_throw(safe_cast_failure, "the floating-point value with nonzero fractional part "
                                                 + std::to_string(f) + " cannot be converted to the integral type '"
                                                 + detail::demangle<To>()
                                                 + "', as the conversion cannot preserve the original value");
        }
        try {
            return boost::numeric_cast<To>(f);
        } catch (...) {
            piranha_throw(safe_cast_failure, "the floating-point value " + std::to_string(f)
                                                 + " cannot be converted to the integral type '"
                                                 + detail::demangle<To>()
                                                 + "', as the conversion cannot preserve the original value");
        }
    }
};

inline namespace impl
{

template <typename To, typename From>
using safe_cast_t_ = decltype(safe_cast_impl<uncvref_t<To>, From>{}(std::declval<const From &>()));

template <typename To, typename From>
using safe_cast_type
    = enable_if_t<conjunction<std::is_same<safe_cast_t_<To, From>, uncvref_t<To>>, is_returnable<uncvref_t<To>>>::value,
                  uncvref_t<To>>;
}


template <typename To, typename From>
inline safe_cast_type<To, From> safe_cast(const From &x)
{
    return safe_cast_impl<uncvref_t<To>, From>{}(x);
}

inline namespace impl
{

template <typename To, typename From>
using safe_cast_t = decltype(safe_cast<To>(std::declval<From>()));
}


template <typename To, typename From>
class has_safe_cast
{
    static const bool implementation_defined = is_detected<safe_cast_t, To, From>::value;

public:
    static const bool value = implementation_defined;
};

// Static init.
template <typename To, typename From>
const bool has_safe_cast<To, From>::value;
}

#endif