Vc/traits/is_functor_argument_immutable.h

0001 /*  This file is part of the Vc library. {{{
0002 Copyright © 2014-2016 Matthias Kretz <kretz@kde.org>
0003
0004 Redistribution and use in source and binary forms, with or without
0005 modification, are permitted provided that the following conditions are met:
0006     * Redistributions of source code must retain the above copyright
0007       notice, this list of conditions and the following disclaimer.
0008     * Redistributions in binary form must reproduce the above copyright
0009       notice, this list of conditions and the following disclaimer in the
0010       documentation and/or other materials provided with the distribution.
0011     * Neither the names of contributing organizations nor the
0012       names of its contributors may be used to endorse or promote products
0013       derived from this software without specific prior written permission.
0014
0015 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
0016 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
0017 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
0018 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
0019 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
0020 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
0021 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
0022 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
0023 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
0024 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0025
0026 }}}*/
0027
0028 #ifndef VC_TRAITS_IS_FUNCTOR_ARGUMENT_IMMUTABLE_H_
0029 #define VC_TRAITS_IS_FUNCTOR_ARGUMENT_IMMUTABLE_H_
0030
0031 namespace Vc_VERSIONED_NAMESPACE
0032 {
0033 namespace Traits
0034 {
0035 namespace is_functor_argument_immutable_impl
0036 {
0037 template <typename F, typename A> std::true_type   test(void (F::*)(A));
0038 template <typename F, typename A> std::true_type   test(void (F::*)(A) const);
0039 template <typename F, typename A> std::is_const<A> test(void (F::*)(A &));
0040 template <typename F, typename A> std::is_const<A> test(void (F::*)(A &) const);
0041 template <typename F, typename A> std::is_const<A> test(void (F::*)(A &&));
0042 template <typename F, typename A> std::is_const<A> test(void (F::*)(A &&) const);
0043
0044 struct dummy {};
0045
0046 // generate a true_type for template operator() members in F that are callable with a
0047 // 'const A &' argument even if the template parameter to operator() is fixed to 'A'.
0048 template <
0049     typename F, typename A,
0050 #ifdef Vc_MSVC
0051 // MSVC fails if the template keyword is used to *correctly* tell the compiler that <A> is
0052 // an explicit template instantiation of operator()
0053 #define Vc_TEMPLATE_
0054 #else
0055 #define Vc_TEMPLATE_ template
0056 #endif
0057     typename MemberPtr = decltype(&F::Vc_TEMPLATE_ operator()<A>)>
0058 decltype(is_functor_argument_immutable_impl::test(std::declval<MemberPtr>())) test2(int);
0059 #undef Vc_TEMPLATE_
0060
0061 // generate a true_type for non-template operator() members in F that are callable with a
0062 // 'const A &' argument.
0063 template <typename F, typename A>
0064 decltype(
0065     is_functor_argument_immutable_impl::test(std::declval<decltype(&F::operator())>()))
0066 test2(float);
0067
0068 template <typename A> std::true_type   test3(void(*)(A));
0069 template <typename A> std::is_const<A> test3(void(*)(A &));
0070 template <typename A> std::is_const<A> test3(void(*)(A &&));
0071
0072 }  // namespace is_functor_argument_immutable_impl
0073
0074 template <typename F, typename A, bool = std::is_function<F>::value>
0075 struct is_functor_argument_immutable;
0076 template <typename F, typename A>
0077 struct is_functor_argument_immutable<F, A, false>
0078     : decltype(is_functor_argument_immutable_impl::test2<
0079                       typename std::remove_reference<F>::type, A>(int())) {
0080 };
0081 template <typename F, typename A>
0082 struct is_functor_argument_immutable<F, A, true>
0083     : decltype(is_functor_argument_immutable_impl::test3(std::declval<F>())) {
0084 };
0085
0086 }  // namespace Traits
0087 }  // namespace Vc
0088
0089 #endif  // VC_TRAITS_IS_FUNCTOR_ARGUMENT_IMMUTABLE_H_
0090
0091 // vim: foldmethod=marker