|
|
#ifndef OPAQUE_BINOP_OVERLOAD_HPP
|
|
|
#define OPAQUE_BINOP_OVERLOAD_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 "../constexpr14.hpp"
|
|
|
#include "../type_traits.hpp"
|
|
|
#include "../utility.hpp"
|
|
|
#include "../convert.hpp"
|
|
|
#include <type_traits>
|
|
|
|
|
|
namespace opaque {
|
|
|
namespace binop {
|
|
|
|
|
|
/// \addtogroup internal
|
|
|
/// @{
|
|
|
|
|
|
///
|
|
|
/// Overloads of binary operators
|
|
|
///
|
|
|
|
|
|
template <typename OP, typename RT, bool apply_commutativity=false,
|
|
|
typename P1=RT, typename P2=RT, typename I1=P1, typename I2=P2>
|
|
|
struct overload;
|
|
|
|
|
|
template <typename OP, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload<OP,RT,false,const P1& ,const P2& ,I1,I2> {
|
|
|
// No return type conversion - enable NRVO
|
|
|
template <typename R=RT> static constexpr14
|
|
|
typename std::enable_if< std::is_same<RT,I1>::value, R>::type
|
|
|
func(const P1& p1, const P2& p2, OP op=OP{}) noexcept(
|
|
|
std::is_nothrow_constructible<I1,const P1&>::value and
|
|
|
noexcept(op(std::declval<I1>(), convert<I2>(p2)))) {
|
|
|
I1 temp(p1);
|
|
|
op(temp, convert<I2>(p2));
|
|
|
return temp;
|
|
|
}
|
|
|
// Return type conversion
|
|
|
template <typename R=RT> static constexpr14
|
|
|
typename std::enable_if<not std::is_same<RT,I1>::value, R>::type
|
|
|
func(const P1& p1, const P2& p2, OP op=OP{}) noexcept(
|
|
|
std::is_nothrow_constructible<I1,const P1&>::value and
|
|
|
std::is_nothrow_constructible<RT,I1&&>::value and
|
|
|
noexcept(op(std::declval<I1>(), convert<I2>(p2)))) {
|
|
|
I1 temp(p1);
|
|
|
op(temp, convert<I2>(p2));
|
|
|
return static_cast<RT>(opaque::move(temp));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
template <typename OP, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload<OP,RT,false,const P1& , P2&&,I1,I2> {
|
|
|
// No return type conversion - enable NRVO
|
|
|
template <typename R=RT> static constexpr14
|
|
|
typename std::enable_if< std::is_same<RT,I1>::value, R>::type
|
|
|
func(const P1& p1, P2&& p2, OP op=OP{}) noexcept(
|
|
|
std::is_nothrow_constructible<I1,const P1&>::value and
|
|
|
noexcept(op(std::declval<I1>(), convert<I2>(opaque::move(p2))))) {
|
|
|
I1 temp(p1);
|
|
|
op(temp, convert<I2>(opaque::move(p2)));
|
|
|
return temp;
|
|
|
}
|
|
|
// Return type conversion
|
|
|
template <typename R=RT> static constexpr14
|
|
|
typename std::enable_if<not std::is_same<RT,I1>::value, R>::type
|
|
|
func(const P1& p1, P2&& p2, OP op=OP{}) noexcept(
|
|
|
std::is_nothrow_constructible<I1,const P1&>::value and
|
|
|
std::is_nothrow_constructible<RT,I1&&>::value and
|
|
|
noexcept(op(std::declval<I1>(), convert<I2>(opaque::move(p2))))) {
|
|
|
I1 temp(p1);
|
|
|
op(temp, convert<I2>(opaque::move(p2)));
|
|
|
return static_cast<RT>(opaque::move(temp));
|
|
|
}
|
|
|
};
|
|
|
|
|
|
template <typename OP, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload<OP,RT,false, P1&&,const P2& ,I1,I2> {
|
|
|
static constexpr RT func( P1&& p1, const P2& p2, OP op=OP{}) noexcept(
|
|
|
noexcept(static_cast<RT>(
|
|
|
op(convert_mutable<I1>(opaque::move(p1)),
|
|
|
convert<I2>( p2 ))))) {
|
|
|
return static_cast<RT>(
|
|
|
op(convert_mutable<I1>(opaque::move(p1)),
|
|
|
convert<I2>( p2 ))); }
|
|
|
};
|
|
|
|
|
|
template <typename OP, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload<OP,RT,false, P1&&, P2&&,I1,I2> {
|
|
|
static constexpr RT func( P1&& p1, P2&& p2, OP op=OP{}) noexcept(
|
|
|
noexcept(static_cast<RT>(
|
|
|
op(convert_mutable<I1>(opaque::move(p1)),
|
|
|
convert<I2>( opaque::move(p2)))))) {
|
|
|
return static_cast<RT>(
|
|
|
op(convert_mutable<I1>(opaque::move(p1)),
|
|
|
convert<I2>( opaque::move(p2)))); }
|
|
|
};
|
|
|
|
|
|
template <typename OP, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload<OP,RT,true,P1,P2,I1,I2> {
|
|
|
using overload_t = overload<OP,RT,false,P2,P1,I2,I1>;
|
|
|
static constexpr RT func(P1&& p1, P2&& p2, OP op=OP{}) noexcept(
|
|
|
noexcept(overload_t::func(
|
|
|
opaque::forward<P2>(p2), opaque::forward<P1>(p1), op))) {
|
|
|
return overload_t::func(
|
|
|
opaque::forward<P2>(p2), opaque::forward<P1>(p1), op);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
//
|
|
|
// Four flavors of overload are required, but we cannot inherit from the same
|
|
|
// base class more than once (ISO/IEC 14882 �10.1/3). Work around this by
|
|
|
// creating four distinct classes to inherit from.
|
|
|
//
|
|
|
|
|
|
template <typename OP, typename RT, bool apply_commutativity,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload_1 : overload<OP,RT,apply_commutativity,P1,P2,I1,I2> { };
|
|
|
|
|
|
template <typename OP, typename RT, bool apply_commutativity,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload_2 : overload<OP,RT,apply_commutativity,P1,P2,I1,I2> { };
|
|
|
|
|
|
template <typename OP, typename RT, bool apply_commutativity,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload_3 : overload<OP,RT,apply_commutativity,P1,P2,I1,I2> { };
|
|
|
|
|
|
template <typename OP, typename RT, bool apply_commutativity,
|
|
|
typename P1, typename P2, typename I1, typename I2>
|
|
|
struct overload_4 : overload<OP,RT,apply_commutativity,P1,P2,I1,I2> { };
|
|
|
|
|
|
///
|
|
|
/// Conversion costs associated with a binary operation
|
|
|
///
|
|
|
/// The parameter types must reflect the actual types passed to the binary
|
|
|
/// operation, e.g. const T& or T&&. All the other types must be decayed
|
|
|
/// types.
|
|
|
///
|
|
|
template<typename return_type, typename result_type,
|
|
|
typename inter1_type, typename inter2_type,
|
|
|
typename param1_type, typename param2_type>
|
|
|
static constexpr unsigned binop_conversion_cost() noexcept {
|
|
|
static_assert(is_decayed<return_type>::value, "");
|
|
|
static_assert(is_decayed<result_type>::value, "");
|
|
|
static_assert(is_decayed<inter1_type>::value, "");
|
|
|
static_assert(is_decayed<inter2_type>::value, "");
|
|
|
return converter<inter1_type,param1_type>::mutable_cost() +
|
|
|
converter<inter2_type,param2_type>::cost() +
|
|
|
converter<return_type,result_type>::cost();
|
|
|
}
|
|
|
|
|
|
///
|
|
|
/// Select between the regular overload and the commutative alternative
|
|
|
///
|
|
|
/// If the operator is not commutative, use the regular overload.
|
|
|
/// Otherwise, if only one option is well-formed, use that.
|
|
|
/// Otherwise, if both are well-formed, select the lower-cost one.
|
|
|
///
|
|
|
|
|
|
template <bool regular_well_formed, bool swapped_well_formed,
|
|
|
typename OPN, typename RT, bool commutative=false,
|
|
|
typename P1=RT, typename P2=RT, typename I1=P1, typename I2=P2,
|
|
|
typename OPS=OPN>
|
|
|
struct overload_selector {
|
|
|
// overload_selector<false,false,OPN,RT,commutative,P1,P2,I1,I2,OPS>
|
|
|
// --> No overload is well-formed
|
|
|
static_assert( swapped_well_formed, "Operation is not well-formed");
|
|
|
// overload_selector<false,true ,OPN,RT,false,P1,P2,I1,I2,OPS>>
|
|
|
// --> Only swapped overload is well-formed, but we can't use it
|
|
|
static_assert(not swapped_well_formed, "Operation is not commutative");
|
|
|
};
|
|
|
|
|
|
template <typename OPN, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2, typename OPS>
|
|
|
struct overload_selector<false,true ,OPN,RT,true ,P1,P2,I1,I2,OPS> {
|
|
|
// Only swapped overload is well-formed, and we can use it
|
|
|
using type_1 = overload_1<OPS,RT,true ,const P1& , const P2& ,I1,I2>;
|
|
|
using type_2 = overload_2<OPS,RT,true ,const P1& , P2&&,I1,I2>;
|
|
|
using type_3 = overload_3<OPS,RT,true , P1&&, const P2& ,I1,I2>;
|
|
|
using type_4 = overload_4<OPS,RT,true , P1&&, P2&&,I1,I2>;
|
|
|
};
|
|
|
|
|
|
template <typename OPN, typename RT, bool commutative,
|
|
|
typename P1, typename P2, typename I1, typename I2, typename OPS>
|
|
|
struct overload_selector<true ,false,OPN,RT,commutative,P1,P2,I1,I2,OPS> {
|
|
|
// Only regular overload is well-formed
|
|
|
using type_1 = overload_1<OPN,RT,false,const P1& , const P2& ,I1,I2>;
|
|
|
using type_2 = overload_2<OPN,RT,false,const P1& , P2&&,I1,I2>;
|
|
|
using type_3 = overload_3<OPN,RT,false, P1&&, const P2& ,I1,I2>;
|
|
|
using type_4 = overload_4<OPN,RT,false, P1&&, P2&&,I1,I2>;
|
|
|
};
|
|
|
|
|
|
template <typename OPN, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2, typename OPS>
|
|
|
struct overload_selector<true ,true ,OPN,RT,false,P1,P2,I1,I2,OPS> {
|
|
|
// Both overloads are well-formed, but we must use the regular one
|
|
|
using type_1 = overload_1<OPN,RT,false,const P1& , const P2& ,I1,I2>;
|
|
|
using type_2 = overload_2<OPN,RT,false,const P1& , P2&&,I1,I2>;
|
|
|
using type_3 = overload_3<OPN,RT,false, P1&&, const P2& ,I1,I2>;
|
|
|
using type_4 = overload_4<OPN,RT,false, P1&&, P2&&,I1,I2>;
|
|
|
};
|
|
|
|
|
|
template <typename OPN, typename RT,
|
|
|
typename P1, typename P2, typename I1, typename I2, typename OPS>
|
|
|
struct overload_selector<true ,true ,OPN,RT,true ,P1,P2,I1,I2,OPS> {
|
|
|
// Both overloads are well-formed, and we must choose between them
|
|
|
|
|
|
template <typename result, typename param1, typename param2>
|
|
|
static constexpr unsigned norm_cost() noexcept {
|
|
|
return binop_conversion_cost<RT,result,I1,I2,param1,param2>();
|
|
|
}
|
|
|
template <typename result, typename param1, typename param2>
|
|
|
static constexpr unsigned swap_cost() noexcept {
|
|
|
return binop_conversion_cost<RT,result,I2,I1,param2,param1>();
|
|
|
}
|
|
|
|
|
|
using RN = typename std::decay<typename
|
|
|
is_functor_call_well_formed<OPN,I1&,const I2&>::result_type>::type;
|
|
|
using RS = typename std::decay<typename
|
|
|
is_functor_call_well_formed<OPS,I2&,const I1&>::result_type>::type;
|
|
|
|
|
|
using type_1 = typename std::conditional<
|
|
|
swap_cost <RS,const P1& ,const P2& >() <
|
|
|
norm_cost <RN,const P1& ,const P2& >(),
|
|
|
overload_1<OPS,RT,true ,const P1& ,const P2& ,I1,I2>,
|
|
|
overload_1<OPN,RT,false,const P1& ,const P2& ,I1,I2>>::type;
|
|
|
using type_2 = typename std::conditional<
|
|
|
swap_cost <RS,const P1& , P2&&>() <
|
|
|
norm_cost <RN,const P1& , P2&&>(),
|
|
|
overload_2<OPS,RT,true ,const P1& , P2&&,I1,I2>,
|
|
|
overload_2<OPN,RT,false,const P1& , P2&&,I1,I2>>::type;
|
|
|
using type_3 = typename std::conditional<
|
|
|
swap_cost <RS, P1&&,const P2& >() <
|
|
|
norm_cost <RN, P1&&,const P2& >(),
|
|
|
overload_3<OPS,RT,true , P1&&,const P2& ,I1,I2>,
|
|
|
overload_3<OPN,RT,false, P1&&,const P2& ,I1,I2>>::type;
|
|
|
using type_4 = typename std::conditional<
|
|
|
swap_cost <RS, P1&&, P2&&>() <
|
|
|
norm_cost <RN, P1&&, P2&&>(),
|
|
|
overload_4<OPS,RT,true , P1&&, P2&&,I1,I2>,
|
|
|
overload_4<OPN,RT,false, P1&&, P2&&,I1,I2>>::type;
|
|
|
};
|
|
|
|
|
|
template <typename OPN, typename RT, bool commutative,
|
|
|
typename P1, typename P2, typename I1, typename I2, typename OPS>
|
|
|
using overload_selector_t = overload_selector<
|
|
|
is_functor_call_well_formed<OPN,I1&,I2>::value,
|
|
|
is_functor_call_well_formed<OPS,I2&,I1>::value,
|
|
|
OPN,RT,commutative,P1,P2,I1,I2,OPS>;
|
|
|
|
|
|
///
|
|
|
/// Generalized binary operator
|
|
|
///
|
|
|
template <typename OPN, typename RT, bool commutative=false,
|
|
|
typename P1=RT, typename P2=RT, typename I1=P1, typename I2=P2,
|
|
|
typename OPS=OPN>
|
|
|
struct binary_operator
|
|
|
: overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_1
|
|
|
, overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_2
|
|
|
, overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_3
|
|
|
, overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_4
|
|
|
{
|
|
|
//
|
|
|
// Inheriting a function with the same name from different base classes is
|
|
|
// ambiguous (ISO/IEC 14882 �10.2/6). Work around this by pulling the
|
|
|
// declarations into the derived class.
|
|
|
//
|
|
|
using overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_1::func;
|
|
|
using overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_2::func;
|
|
|
using overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_3::func;
|
|
|
using overload_selector_t<OPN,RT,commutative,P1,P2,I1,I2,OPS>::type_4::func;
|
|
|
};
|
|
|
|
|
|
/// @}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
