// Copyright 2019 Hans Dembinski
|
//
|
// 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)
|
|
#ifndef BOOST_HISTOGRAM_DETAIL_OPERATORS_HPP
|
#define BOOST_HISTOGRAM_DETAIL_OPERATORS_HPP
|
|
#include <boost/histogram/detail/detect.hpp>
|
#include <boost/mp11/algorithm.hpp>
|
#include <boost/mp11/list.hpp>
|
#include <boost/mp11/utility.hpp>
|
#include <type_traits>
|
|
namespace boost {
|
namespace histogram {
|
namespace detail {
|
|
template <class T, class U>
|
using if_not_same = std::enable_if_t<(!std::is_same<T, U>::value), bool>;
|
|
// template <class T, class U>
|
// using if_not_same_and_has_eq =
|
// std::enable_if_t<(!std::is_same<T, U>::value && !has_method_eq<T, U>::value),
|
// bool>;
|
|
// totally_ordered is for types with a <= b == !(a > b) [floats with NaN violate this]
|
// Derived must implement <,== for symmetric form and <,>,== for non-symmetric.
|
|
// partially_ordered is for types with a <= b == a < b || a == b [for floats with NaN]
|
// Derived must implement <,== for symmetric form and <,>,== for non-symmetric.
|
|
template <class T, class U>
|
struct mirrored {
|
friend bool operator<(const U& a, const T& b) noexcept { return b > a; }
|
friend bool operator>(const U& a, const T& b) noexcept { return b < a; }
|
friend bool operator==(const U& a, const T& b) noexcept { return b == a; }
|
friend bool operator<=(const U& a, const T& b) noexcept { return b >= a; }
|
friend bool operator>=(const U& a, const T& b) noexcept { return b <= a; }
|
friend bool operator!=(const U& a, const T& b) noexcept { return b != a; }
|
}; // namespace histogram
|
|
template <class T>
|
struct mirrored<T, void> {
|
template <class U>
|
friend if_not_same<T, U> operator<(const U& a, const T& b) noexcept {
|
return b > a;
|
}
|
template <class U>
|
friend if_not_same<T, U> operator>(const U& a, const T& b) noexcept {
|
return b < a;
|
}
|
template <class U>
|
friend std::enable_if_t<(!has_method_eq<U, T>::value), bool> operator==(
|
const U& a, const T& b) noexcept {
|
return b.operator==(a);
|
}
|
template <class U>
|
friend if_not_same<T, U> operator<=(const U& a, const T& b) noexcept {
|
return b >= a;
|
}
|
template <class U>
|
friend if_not_same<T, U> operator>=(const U& a, const T& b) noexcept {
|
return b <= a;
|
}
|
template <class U>
|
friend if_not_same<T, U> operator!=(const U& a, const T& b) noexcept {
|
return b != a;
|
}
|
};
|
|
template <class T>
|
struct mirrored<T, T> {
|
friend bool operator>(const T& a, const T& b) noexcept { return b.operator<(a); }
|
};
|
|
template <class T, class U>
|
struct equality {
|
friend bool operator!=(const T& a, const U& b) noexcept { return !a.operator==(b); }
|
};
|
|
template <class T>
|
struct equality<T, void> {
|
template <class U>
|
friend if_not_same<T, U> operator!=(const T& a, const U& b) noexcept {
|
return !(a == b);
|
}
|
};
|
|
template <class T, class U>
|
struct totally_ordered_impl : equality<T, U>, mirrored<T, U> {
|
friend bool operator<=(const T& a, const U& b) noexcept { return !(a > b); }
|
friend bool operator>=(const T& a, const U& b) noexcept { return !(a < b); }
|
};
|
|
template <class T>
|
struct totally_ordered_impl<T, void> : equality<T, void>, mirrored<T, void> {
|
template <class U>
|
friend if_not_same<T, U> operator<=(const T& a, const U& b) noexcept {
|
return !(a > b);
|
}
|
template <class U>
|
friend if_not_same<T, U> operator>=(const T& a, const U& b) noexcept {
|
return !(a < b);
|
}
|
};
|
|
template <class T, class... Ts>
|
using totally_ordered = mp11::mp_rename<
|
mp11::mp_product<totally_ordered_impl, mp11::mp_list<T>, mp11::mp_list<Ts...> >,
|
mp11::mp_inherit>;
|
|
template <class T, class U>
|
struct partially_ordered_impl : equality<T, U>, mirrored<T, U> {
|
friend bool operator<=(const T& a, const U& b) noexcept { return a < b || a == b; }
|
friend bool operator>=(const T& a, const U& b) noexcept { return a > b || a == b; }
|
};
|
|
template <class T>
|
struct partially_ordered_impl<T, void> : equality<T, void>, mirrored<T, void> {
|
template <class U>
|
friend if_not_same<T, U> operator<=(const T& a, const U& b) noexcept {
|
return a < b || a == b;
|
}
|
template <class U>
|
friend if_not_same<T, U> operator>=(const T& a, const U& b) noexcept {
|
return a > b || a == b;
|
}
|
};
|
|
template <class T, class... Ts>
|
using partially_ordered = mp11::mp_rename<
|
mp11::mp_product<partially_ordered_impl, mp11::mp_list<T>, mp11::mp_list<Ts...> >,
|
mp11::mp_inherit>;
|
|
} // namespace detail
|
} // namespace histogram
|
} // namespace boost
|
|
#endif // BOOST_HISTOGRAM_DETAIL_OPERATORS_HPP
|
