robot/include/boost/geometry/util/select_most_precise.hpp

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.

// This file was modified by Oracle on 2014-2020.
// Modifications copyright (c) 2014-2020 Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle

// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.

// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_GEOMETRY_UTIL_SELECT_MOST_PRECISE_HPP
#define BOOST_GEOMETRY_UTIL_SELECT_MOST_PRECISE_HPP


#include <type_traits>


namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL

namespace detail { namespace select_most_precise
{


// 0 - void
// 1 - integral
// 2 - floating point
// 3 - non-fundamental
template <typename T>
struct type_priority
    : std::conditional_t
        <
            std::is_void<T>::value,
            std::integral_constant<int, 0>,
            std::conditional_t
                <
                    std::is_fundamental<T>::value,
                    std::conditional_t
                        <
                            std::is_floating_point<T>::value,
                            std::integral_constant<int, 2>,
                            std::integral_constant<int, 1>
                        >,
                    std::integral_constant<int, 3>
                >
        >
{};


template <typename T>
struct type_size
    : std::integral_constant<std::size_t, sizeof(T)>
{};

template <>
struct type_size<void>
    : std::integral_constant<std::size_t, 0>
{};


}} // namespace detail::select_most_precise
#endif // DOXYGEN_NO_DETAIL


/*!
    \brief Meta-function to select the most accurate type for
        calculations
    \ingroup utility
    \details select_most_precise classes, compares types on compile time.
    For example, if an addition must be done with a double and an integer, the
        result must be a double.
    If both types are integer, the result can be an integer.
    \note It is different from the "promote" class, already in boost. That
        class promotes e.g. a (one) float to a double. This class selects a
        type from two types. It takes the most accurate, but does not promote
        afterwards.
    \note If the input is a non-fundamental type, it might be a calculation
        type such as a GMP-value or another high precision value. Therefore,
        if one is non-fundamental, that one is chosen.
    \note If both types are non-fundamental, the result is indeterminate and
        currently the first one is chosen.
*/
template <typename ...Types>
struct select_most_precise
{
    typedef void type;
};

template <typename T>
struct select_most_precise<T>
{
    typedef T type;
};

template <typename T1, typename T2>
struct select_most_precise<T1, T2>
{
    static const int priority1 = detail::select_most_precise::type_priority<T1>::value;
    static const int priority2 = detail::select_most_precise::type_priority<T2>::value;
    static const std::size_t size1 = detail::select_most_precise::type_size<T1>::value;
    static const std::size_t size2 = detail::select_most_precise::type_size<T2>::value;

    typedef std::conditional_t
        <
            (priority1 > priority2),
            T1,
            std::conditional_t
                <
                    (priority2 > priority1),
                    T2,
                    std::conditional_t // priority1 == priority2
                        <
                            (priority1 == 0 || priority1 == 3), // both void or non-fundamental
                            T1,
                            std::conditional_t // both fundamental
                                <
                                    (size2 > size1),
                                    T2,
                                    T1
                                >
                        >
                >
        > type;
};

template <typename T1, typename T2, typename ...Types>
struct select_most_precise<T1, T2, Types...>
{
    typedef typename select_most_precise
        <
            typename select_most_precise<T1, T2>::type,
            typename select_most_precise<Types...>::type
        >::type type;
};


}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_UTIL_SELECT_MOST_PRECISE_HPP