|
|
#ifndef OPAQUE_BINOP_FUNCTION_HPP
|
|
|
#define OPAQUE_BINOP_FUNCTION_HPP
|
|
|
//
|
|
|
// Copyright (c) 2015, 2016
|
|
|
// Kyle Markley. All rights reserved.
|
|
|
//
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
// modification, are permitted provided that the following conditions are met:
|
|
|
//
|
|
|
// 1. Redistributions of source code must retain the above copyright notice,
|
|
|
// this list of conditions and the following disclaimer.
|
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
|
// and/or other materials provided with the distribution.
|
|
|
// 3. Neither the name of the author nor the names of any contributors may be
|
|
|
// used to endorse or promote products derived from this software without
|
|
|
// specific prior written permission.
|
|
|
//
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
//
|
|
|
#include "../utility.hpp"
|
|
|
#include <type_traits>
|
|
|
|
|
|
namespace opaque {
|
|
|
namespace binop {
|
|
|
|
|
|
/// \addtogroup miscellaneous
|
|
|
/// @{
|
|
|
|
|
|
//
|
|
|
// Functions implementing the ordinary operator@= variations
|
|
|
//
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto multiply_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l *= r))
|
|
|
-> decltype(l *= r) {
|
|
|
return l *= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto divide_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l /= r))
|
|
|
-> decltype(l /= r) {
|
|
|
return l /= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto modulus_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l %= r))
|
|
|
-> decltype(l %= r) {
|
|
|
return l %= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto add_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l += r))
|
|
|
-> decltype(l += r) {
|
|
|
return l += r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto subtract_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l -= r))
|
|
|
-> decltype(l -= r) {
|
|
|
return l -= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto left_shift_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l <<= r))
|
|
|
-> decltype(l <<= r) {
|
|
|
return l <<= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto right_shift_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l >>= r))
|
|
|
-> decltype(l >>= r) {
|
|
|
return l >>= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto bitand_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l &= r))
|
|
|
-> decltype(l &= r) {
|
|
|
return l &= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto bitxor_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l ^= r))
|
|
|
-> decltype(l ^= r) {
|
|
|
return l ^= r; }
|
|
|
|
|
|
template <typename T, typename U>
|
|
|
constexpr auto bitor_equal(T& l, const U& r)
|
|
|
noexcept(noexcept(l |= r))
|
|
|
-> decltype(l |= r) {
|
|
|
return l |= r; }
|
|
|
|
|
|
//
|
|
|
// These variants accept and modify temporary objects, and return by value.
|
|
|
// This allows them to be used in expressions without named variables, such
|
|
|
// as multiply_equal(T(l),r).
|
|
|
//
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto multiply_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l *= r))) -> typename
|
|
|
std::decay<decltype(l *= r)>::type {
|
|
|
return opaque::move(l *= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto divide_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l /= r))) -> typename
|
|
|
std::decay<decltype(l /= r)>::type {
|
|
|
return opaque::move(l /= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto modulus_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l %= r))) -> typename
|
|
|
std::decay<decltype(l %= r)>::type {
|
|
|
return opaque::move(l %= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto add_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l += r))) -> typename
|
|
|
std::decay<decltype(l += r)>::type {
|
|
|
return opaque::move(l += r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto subtract_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l -= r))) -> typename
|
|
|
std::decay<decltype(l -= r)>::type {
|
|
|
return opaque::move(l -= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto left_shift_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l <<= r))) -> typename
|
|
|
std::decay<decltype(l <<= r)>::type {
|
|
|
return opaque::move(l <<= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto right_shift_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l >>= r))) -> typename
|
|
|
std::decay<decltype(l >>= r)>::type {
|
|
|
return opaque::move(l >>= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto bitand_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l &= r))) -> typename
|
|
|
std::decay<decltype(l &= r)>::type {
|
|
|
return opaque::move(l &= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto bitxor_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l ^= r))) -> typename
|
|
|
std::decay<decltype(l ^= r)>::type {
|
|
|
return opaque::move(l ^= r); }
|
|
|
|
|
|
template <typename T, typename U, typename = typename
|
|
|
std::enable_if<not std::is_lvalue_reference<T>::value>::type>
|
|
|
constexpr auto bitor_equal(T&& l, const U& r)
|
|
|
noexcept(noexcept(opaque::move(l |= r))) -> typename
|
|
|
std::decay<decltype(l |= r)>::type {
|
|
|
return opaque::move(l |= r); }
|
|
|
|
|
|
//
|
|
|
// Functor objects that forward to the appropriate function.
|
|
|
// Note that the function name is qualified to inhibit ADL.
|
|
|
//
|
|
|
|
|
|
#define OPAQUE_BINOP_FORWARD(F) \
|
|
|
template <typename T, typename U> \
|
|
|
constexpr auto operator()(T&& l, U&& r) const noexcept( \
|
|
|
noexcept(opaque::binop::F(opaque::forward<T>(l), opaque::forward<U>(r)))) -> \
|
|
|
decltype(opaque::binop::F(opaque::forward<T>(l), opaque::forward<U>(r))) { \
|
|
|
return opaque::binop::F(opaque::forward<T>(l), opaque::forward<U>(r)); } \
|
|
|
|
|
|
struct multiply_equal_t { OPAQUE_BINOP_FORWARD( multiply_equal) };
|
|
|
struct divide_equal_t { OPAQUE_BINOP_FORWARD( divide_equal) };
|
|
|
struct modulus_equal_t { OPAQUE_BINOP_FORWARD( modulus_equal) };
|
|
|
struct add_equal_t { OPAQUE_BINOP_FORWARD( add_equal) };
|
|
|
struct subtract_equal_t { OPAQUE_BINOP_FORWARD( subtract_equal) };
|
|
|
struct left_shift_equal_t { OPAQUE_BINOP_FORWARD( left_shift_equal) };
|
|
|
struct right_shift_equal_t { OPAQUE_BINOP_FORWARD(right_shift_equal) };
|
|
|
struct bitand_equal_t { OPAQUE_BINOP_FORWARD( bitand_equal) };
|
|
|
struct bitxor_equal_t { OPAQUE_BINOP_FORWARD( bitxor_equal) };
|
|
|
struct bitor_equal_t { OPAQUE_BINOP_FORWARD( bitor_equal) };
|
|
|
|
|
|
#undef OPAQUE_BINOP_FORWARD
|
|
|
|
|
|
/// @}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
