Suyu/ext-boost
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/ext-boost.git synced 2026-01-07 15:08:16 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

externals: Update boost to 1.72 and add Boost Context

Browse source
This commit is contained in:
Fernando Sahmkow 2020-02-10 12:31:57 -04:00
parent 5e8300b76a
commit 77abe07b3b
618 changed files with 96299 additions and 14263 deletions
Download patch file Download diff file Expand all files Collapse all files

180
boost/safe_numerics/safe_compare.hpp
View file

@ -1,180 +0,0 @@
#ifndef BOOST_NUMERIC_SAFE_COMPARE_HPP
#define BOOST_NUMERIC_SAFE_COMPARE_HPP
// Copyright (c) 2012 Robert Ramey
//
// Distributed under 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)
#include <type_traits>
#include <limits>
namespace boost {
namespace safe_numerics {
namespace safe_compare {
////////////////////////////////////////////////////
// safe comparison on primitive integral types
namespace safe_compare_detail {
template<typename T>
using make_unsigned = typename std::conditional<
std::is_signed<T>::value,
std::make_unsigned<T>,
T
>::type;
// both arguments unsigned or signed
template<bool TS, bool US>
struct less_than {
template<class T, class U>
constexpr static bool invoke(const T & t, const U & u){
return t < u;
}
};
// T unsigned, U signed
template<>
struct less_than<false, true> {
template<class T, class U>
constexpr static bool invoke(const T & t, const U & u){
return
(u < 0) ?
false
:
less_than<false, false>::invoke(
t,
static_cast<const typename make_unsigned<U>::type &>(u)
)
;
}
};
// T signed, U unsigned
template<>
struct less_than<true, false> {
template<class T, class U>
constexpr static bool invoke(const T & t, const U & u){
return
(t < 0) ?
true
:
less_than<false, false>::invoke(
static_cast<const typename make_unsigned<T>::type &>(t),
u
)
;
}
};
} // safe_compare_detail
template<class T, class U>
typename std::enable_if<
std::is_integral<T>::value && std::is_integral<U>::value,
bool
>::type
constexpr less_than(const T & lhs, const U & rhs) {
return safe_compare_detail::less_than<
std::is_signed<T>::value,
std::is_signed<U>::value
>::template invoke(lhs, rhs);
}
template<class T, class U>
typename std::enable_if<
std::is_floating_point<T>::value && std::is_floating_point<U>::value,
bool
>::type
constexpr less_than(const T & lhs, const U & rhs) {
return lhs < rhs;
}
template<class T, class U>
constexpr bool greater_than(const T & lhs, const U & rhs) {
return less_than(rhs, lhs);
}
template<class T, class U>
constexpr bool less_than_equal(const T & lhs, const U & rhs) {
return ! greater_than(lhs, rhs);
}
template<class T, class U>
constexpr bool greater_than_equal(const T & lhs, const U & rhs) {
return ! less_than(lhs, rhs);
}
namespace safe_compare_detail {
// both arguments unsigned or signed
template<bool TS, bool US>
struct equal {
template<class T, class U>
constexpr static bool invoke(const T & t, const U & u){
return t == u;
}
};
// T unsigned, U signed
template<>
struct equal<false, true> {
template<class T, class U>
constexpr static bool invoke(const T & t, const U & u){
return
(u < 0) ?
false
:
equal<false, false>::invoke(
t,
static_cast<const typename make_unsigned<U>::type &>(u)
)
;
}
};
// T signed, U unsigned
template<>
struct equal<true, false> {
template<class T, class U>
constexpr static bool invoke(const T & t, const U & u){
return
(t < 0) ?
false
:
equal<false, false>::invoke(
static_cast<const typename make_unsigned<T>::type &>(t),
u
)
;
}
};
} // safe_compare_detail
template<class T, class U>
typename std::enable_if<
std::is_integral<T>::value && std::is_integral<U>::value,
bool
>::type
constexpr equal(const T & lhs, const U & rhs) {
return safe_compare_detail::equal<
std::numeric_limits<T>::is_signed,
std::numeric_limits<U>::is_signed
>::template invoke(lhs, rhs);
}
template<class T, class U>
typename std::enable_if<
std::is_floating_point<T>::value && std::is_floating_point<U>::value,
bool
>::type
constexpr equal(const T & lhs, const U & rhs) {
return lhs == rhs;
}
template<class T, class U>
constexpr bool not_equal(const T & lhs, const U & rhs) {
return ! equal(lhs, rhs);
}
} // safe_compare
} // safe_numerics
} // boost
#endif // BOOST_NUMERIC_SAFE_COMPARE_HPP