| // Boost.TypeErasure library |
| // |
| // Copyright 2011 Steven Watanabe |
| // |
| // 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) |
| // |
| // $Id$ |
| |
| #ifndef BOOST_TYPE_ERASURE_OPERATORS_HPP_INCLUDED |
| #define BOOST_TYPE_ERASURE_OPERATORS_HPP_INCLUDED |
| |
| #include <iosfwd> |
| #include <boost/utility/enable_if.hpp> |
| #include <boost/type_erasure/detail/const.hpp> |
| #include <boost/type_erasure/call.hpp> |
| #include <boost/type_erasure/concept_interface.hpp> |
| #include <boost/type_erasure/placeholder.hpp> |
| #include <boost/type_erasure/concept_of.hpp> |
| #include <boost/type_erasure/derived.hpp> |
| #include <boost/type_erasure/rebind_any.hpp> |
| #include <boost/type_erasure/param.hpp> |
| #include <boost/type_erasure/check_match.hpp> |
| #include <boost/type_erasure/relaxed.hpp> |
| #include <boost/type_erasure/typeid_of.hpp> |
| |
| namespace boost { |
| namespace type_erasure { |
| |
| template<class Concept, class Placeholder> |
| class any; |
| |
| /** INTERNAL ONLY */ |
| #define BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(name, op) \ |
| template<class T = _self> \ |
| struct name \ |
| { \ |
| static void apply(T& arg) { op arg; } \ |
| }; \ |
| \ |
| template<class T, class Base> \ |
| struct concept_interface<name<T>, Base, T, \ |
| typename ::boost::enable_if< \ |
| detail::should_be_non_const<T, Base> \ |
| >::type \ |
| > : Base \ |
| { \ |
| typedef typename ::boost::type_erasure::derived<Base>::type _derived; \ |
| _derived& operator op() \ |
| { \ |
| ::boost::type_erasure::call(name<T>(), *this); \ |
| return static_cast<_derived&>(*this); \ |
| } \ |
| typename ::boost::type_erasure::rebind_any<Base, T>::type operator op(int) \ |
| { \ |
| typename ::boost::type_erasure::rebind_any<Base, T>::type result( \ |
| static_cast<_derived&>(*this)); \ |
| ::boost::type_erasure::call(name<T>(), *this); \ |
| return result; \ |
| } \ |
| }; \ |
| \ |
| template<class T, class Base> \ |
| struct concept_interface<name<T>, Base, T, \ |
| typename ::boost::enable_if< \ |
| detail::should_be_const<T, Base> \ |
| >::type \ |
| > : Base \ |
| { \ |
| typedef typename ::boost::type_erasure::derived<Base>::type _derived; \ |
| const _derived& operator op() const \ |
| { \ |
| ::boost::type_erasure::call(name<T>(), *this); \ |
| return static_cast<const _derived&>(*this); \ |
| } \ |
| typename ::boost::type_erasure::rebind_any<Base, T>::type operator op(int) const \ |
| { \ |
| typename ::boost::type_erasure::rebind_any<Base, T>::type result( \ |
| static_cast<const _derived&>(*this)); \ |
| ::boost::type_erasure::call(name<T>(), *this); \ |
| return result; \ |
| } \ |
| }; |
| |
| /** |
| * The @ref incrementable concept allow pre and |
| * post increment on an @ref any. The contained |
| * type must provide a pre-increment operator. |
| */ |
| BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(incrementable, ++) |
| /** |
| * The @ref decrementable concept allow pre and |
| * post decrement on an @ref any. The contained |
| * type must provide a pre-decrement operator. |
| */ |
| BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(decrementable, --) |
| |
| #undef BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR |
| |
| /** INTERNAL ONLY */ |
| #define BOOST_TYPE_ERASURE_UNARY_OPERATOR(name, op) \ |
| template<class T = _self, class R = T> \ |
| struct name \ |
| { \ |
| static R apply(const T& arg) { return op arg; } \ |
| }; \ |
| \ |
| template<class T, class R, class Base> \ |
| struct concept_interface<name<T, R>, Base, T> : Base \ |
| { \ |
| typename ::boost::type_erasure::rebind_any<Base, R>::type operator op() const \ |
| { \ |
| return ::boost::type_erasure::call(name<T, R>(), *this); \ |
| } \ |
| }; |
| |
| /** |
| * The @ref complementable concept allow use of the bitwise |
| * complement operator on an @ref any. |
| */ |
| BOOST_TYPE_ERASURE_UNARY_OPERATOR(complementable, ~) |
| /** |
| * The @ref negatable concept allow use of the unary |
| * minus operator on an @ref any. |
| */ |
| BOOST_TYPE_ERASURE_UNARY_OPERATOR(negatable, -) |
| |
| #undef BOOST_TYPE_ERASURE_UNARY_OPERATOR |
| |
| template<class R, class T = _self> |
| struct dereferenceable |
| { |
| static R apply(const T& arg) { return *arg; } |
| }; |
| |
| /// \cond show_operators |
| |
| template<class R, class T, class Base> |
| struct concept_interface<dereferenceable<R, T>, Base, T> : Base |
| { |
| typename ::boost::type_erasure::rebind_any<Base, R>::type operator*() const |
| { |
| return ::boost::type_erasure::call(dereferenceable<R, T>(), *this); |
| } |
| }; |
| |
| /// \endcond |
| |
| /** INTERNAL ONLY */ |
| #define BOOST_TYPE_ERASURE_BINARY_OPERATOR(name, op) \ |
| template<class T = _self, class U = T, class R = T> \ |
| struct name \ |
| { \ |
| static R apply(const T& lhs, const U& rhs) { return lhs op rhs; } \ |
| }; \ |
| \ |
| template<class T, class U, class R, class Base> \ |
| struct concept_interface<name<T, U, R>, Base, T> : Base \ |
| { \ |
| friend typename rebind_any<Base, R>::type \ |
| operator op(const typename derived<Base>::type& lhs, \ |
| typename as_param<Base, const U&>::type rhs) \ |
| { \ |
| return ::boost::type_erasure::call(name<T, U, R>(), lhs, rhs); \ |
| } \ |
| }; \ |
| \ |
| template<class T, class U, class R, class Base> \ |
| struct concept_interface< \ |
| name<T, U, R>, \ |
| Base, \ |
| U, \ |
| typename ::boost::disable_if< \ |
| ::boost::type_erasure::is_placeholder<T> >::type \ |
| > : Base \ |
| { \ |
| friend typename rebind_any<Base, R>::type \ |
| operator op(const T& lhs, \ |
| const typename derived<Base>::type& rhs) \ |
| { \ |
| return ::boost::type_erasure::call(name<T, U, R>(), lhs, rhs); \ |
| } \ |
| }; |
| |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(addable, +) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(subtractable, -) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(multipliable, *) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(dividable, /) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(modable, %) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(left_shiftable, <<) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(right_shiftable, >>) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitandable, &) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitorable, |) |
| BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitxorable, ^) |
| |
| #undef BOOST_TYPE_ERASURE_BINARY_OPERATOR |
| |
| /** INTERNAL ONLY */ |
| #define BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(name, op) \ |
| template<class T = _self, class U = T> \ |
| struct name \ |
| { \ |
| static void apply(T& lhs, const U& rhs) { lhs op rhs; } \ |
| }; \ |
| \ |
| template<class T, class U, class Base> \ |
| struct concept_interface<name<T, U>, Base, T, \ |
| typename ::boost::disable_if< \ |
| ::boost::is_same< \ |
| typename ::boost::type_erasure::placeholder_of<Base>::type, \ |
| const T& \ |
| > \ |
| >::type \ |
| > : Base \ |
| { \ |
| friend typename detail::non_const_this_param<Base>::type& \ |
| operator op(typename detail::non_const_this_param<Base>::type& lhs, \ |
| typename as_param<Base, const U&>::type rhs) \ |
| { \ |
| ::boost::type_erasure::call(name<T, U>(),lhs, rhs); \ |
| return lhs; \ |
| } \ |
| }; \ |
| \ |
| template<class T, class U, class Base> \ |
| struct concept_interface< \ |
| name<T, U>, \ |
| Base, \ |
| U, \ |
| typename ::boost::disable_if< \ |
| ::boost::type_erasure::is_placeholder<T> >::type \ |
| > : Base \ |
| { \ |
| friend T& \ |
| operator op(T& lhs, const typename derived<Base>::type& rhs) \ |
| { \ |
| ::boost::type_erasure::call(name<T, U>(),lhs, rhs); \ |
| return lhs; \ |
| } \ |
| }; |
| |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(add_assignable, +=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(subtract_assignable, -=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(multiply_assignable, *=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(divide_assignable, /=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(mod_assignable, %=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(left_shift_assignable, <<=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(right_shift_assignable, >>=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitand_assignable, &=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitor_assignable, |=) |
| BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitxor_assignable, ^=) |
| |
| #undef BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR |
| |
| template<class T = _self, class U = T> |
| struct equality_comparable |
| { |
| static bool apply(const T& lhs, const U& rhs) { return lhs == rhs; } |
| }; |
| |
| /// \cond show_operators |
| |
| template<class T, class U, class Base> |
| struct concept_interface<equality_comparable<T, U>, Base, T> : Base |
| { |
| friend bool operator==(const typename derived<Base>::type& lhs, |
| typename as_param<Base, const U&>::type rhs) |
| { |
| if(::boost::type_erasure::check_match(equality_comparable<T, U>(), lhs, rhs)) { |
| return ::boost::type_erasure::unchecked_call(equality_comparable<T, U>(), lhs, rhs); |
| } else { |
| return false; |
| } |
| } |
| friend bool operator!=(const typename derived<Base>::type& lhs, |
| typename as_param<Base, const U&>::type rhs) |
| { |
| return !(lhs == rhs); |
| } |
| }; |
| |
| template<class T, class U, class Base> |
| struct concept_interface< |
| equality_comparable<T, U>, |
| Base, |
| U, |
| typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<T> >::type |
| > : Base |
| { |
| friend bool operator==(const T& lhs, const typename derived<Base>::type& rhs) |
| { |
| return ::boost::type_erasure::call(equality_comparable<T, U>(), lhs, rhs); |
| } |
| friend bool operator!=(const T& lhs, const typename derived<Base>::type& rhs) |
| { |
| return !(lhs == rhs); |
| } |
| }; |
| |
| /// \endcond |
| |
| template<class T = _self, class U = T> |
| struct less_than_comparable |
| { |
| static bool apply(const T& lhs, const U& rhs) { return lhs < rhs; } |
| }; |
| |
| namespace detail { |
| |
| template<class F, class T, class U> |
| bool less_impl(const F& f, const T& lhs, const U& rhs, ::boost::mpl::true_) |
| { |
| if(::boost::type_erasure::check_match(f, lhs, rhs)) { |
| return ::boost::type_erasure::unchecked_call(f, lhs, rhs); |
| } else { |
| return ::boost::type_erasure::typeid_of( |
| static_cast<const typename derived<T>::type&>(lhs) |
| ).before( |
| ::boost::type_erasure::typeid_of( |
| static_cast<const typename derived<U>::type&>(rhs) |
| ) |
| ) != false; |
| } |
| } |
| |
| template<class F, class T, class U> |
| bool less_impl(const F& f, const T& lhs, const U& rhs, ::boost::mpl::false_) |
| { |
| return ::boost::type_erasure::call(f, lhs, rhs); |
| } |
| |
| } |
| |
| /// \cond show_operators |
| |
| template<class T, class Base> |
| struct concept_interface<less_than_comparable<T, T>, Base, T> : Base |
| { |
| friend bool operator<(const typename derived<Base>::type& lhs, |
| typename as_param<Base, const T&>::type rhs) |
| { |
| return ::boost::type_erasure::detail::less_impl( |
| less_than_comparable<T, T>(), |
| lhs, rhs, |
| ::boost::type_erasure::is_relaxed< |
| typename ::boost::type_erasure::concept_of<Base>::type>()); |
| } |
| friend bool operator>=(const typename derived<Base>::type& lhs, |
| typename as_param<Base, const T&>::type rhs) |
| { |
| return !(lhs < rhs); |
| } |
| friend bool operator>(typename as_param<Base, const T&>::type lhs, |
| const typename derived<Base>::type& rhs) |
| { |
| return rhs < lhs; |
| } |
| friend bool operator<=(typename as_param<Base, const T&>::type lhs, |
| const typename derived<Base>::type& rhs) |
| { |
| return !(rhs < lhs); |
| } |
| }; |
| |
| template<class T, class U, class Base> |
| struct concept_interface<less_than_comparable<T, U>, Base, T> : Base |
| { |
| friend bool operator<(const typename derived<Base>::type& lhs, |
| typename as_param<Base, const U&>::type rhs) |
| { |
| return ::boost::type_erasure::call(less_than_comparable<T, U>(), lhs, rhs); |
| } |
| friend bool operator>=(const typename derived<Base>::type& lhs, |
| typename as_param<Base, const U&>::type rhs) |
| { |
| return !(lhs < rhs); |
| } |
| friend bool operator>(typename as_param<Base, const U&>::type lhs, |
| const typename derived<Base>::type& rhs) |
| { |
| return rhs < lhs; |
| } |
| friend bool operator<=(typename as_param<Base, const U&>::type lhs, |
| const typename derived<Base>::type& rhs) |
| { |
| return !(rhs < lhs); |
| } |
| }; |
| |
| template<class T, class U, class Base> |
| struct concept_interface< |
| less_than_comparable<T, U>, |
| Base, |
| U, |
| typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<T> >::type |
| > : Base |
| { |
| friend bool operator<(const T& lhs, const typename derived<Base>::type& rhs) |
| { |
| return ::boost::type_erasure::call(less_than_comparable<T, U>(), lhs, rhs); |
| } |
| friend bool operator>=(const T& lhs, const typename derived<Base>::type& rhs) |
| { |
| return !(lhs < rhs); |
| } |
| friend bool operator>(const typename derived<Base>::type& lhs, const T& rhs) |
| { |
| return rhs < lhs; |
| } |
| friend bool operator<=(const typename derived<Base>::type& lhs, const T& rhs) |
| { |
| return !(rhs < lhs); |
| } |
| }; |
| |
| /// \endcond |
| |
| template<class R, class T = _self, class N = std::ptrdiff_t> |
| struct subscriptable |
| { |
| static R apply(T& arg, const N& index) { return arg[index]; } |
| }; |
| |
| /// \cond show_operators |
| |
| template<class R, class T, class N, class Base> |
| struct concept_interface<subscriptable<R, T, N>, Base, typename ::boost::remove_const<T>::type, |
| typename ::boost::enable_if< |
| ::boost::type_erasure::detail::should_be_non_const<T, Base> |
| >::type |
| > : Base |
| { |
| typename ::boost::type_erasure::rebind_any<Base, R>::type operator[]( |
| typename ::boost::type_erasure::as_param<Base, const N&>::type index) |
| { |
| return ::boost::type_erasure::call(subscriptable<R, T, N>(), *this, index); |
| } |
| }; |
| |
| template<class R, class T, class N, class Base> |
| struct concept_interface<subscriptable<R, T, N>, Base, typename ::boost::remove_const<T>::type, |
| typename ::boost::enable_if< |
| ::boost::type_erasure::detail::should_be_const<T, Base> |
| >::type |
| > : Base |
| { |
| typename ::boost::type_erasure::rebind_any<Base, R>::type operator[]( |
| typename ::boost::type_erasure::as_param<Base, const N&>::type index) const |
| { |
| return ::boost::type_erasure::call(subscriptable<R, const T, N>(), *this, index); |
| } |
| }; |
| |
| /// \endcond |
| |
| /** |
| * The @ref ostreamable concept allows an @ref any to be |
| * written to a @c std::ostream. |
| */ |
| template<class Os = std::ostream, class T = _self> |
| struct ostreamable |
| { |
| static void apply(Os& out, const T& arg) { out << arg; } |
| }; |
| |
| /// \cond show_operators |
| |
| template<class Base, class Os, class T> |
| struct concept_interface<ostreamable<Os, T>, Base, Os> : Base |
| { |
| friend typename detail::non_const_this_param<Base>::type& |
| operator<<(typename detail::non_const_this_param<Base>::type& lhs, |
| typename ::boost::type_erasure::as_param<Base, const T&>::type rhs) |
| { |
| ::boost::type_erasure::call(ostreamable<Os, T>(), lhs, rhs); |
| return lhs; |
| } |
| }; |
| |
| template<class Base, class Os, class T> |
| struct concept_interface< |
| ostreamable<Os, T>, |
| Base, |
| T, |
| typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<Os> >::type |
| > : Base |
| { |
| friend Os& |
| operator<<(Os& lhs, |
| const typename ::boost::type_erasure::derived<Base>::type& rhs) |
| { |
| ::boost::type_erasure::call(ostreamable<Os, T>(), lhs, rhs); |
| return lhs; |
| } |
| }; |
| |
| /// \endcond |
| |
| /** |
| * The @ref istreamable concept allows an @ref any to be |
| * read from a @c std::istream. |
| */ |
| template<class Is = std::istream, class T = _self> |
| struct istreamable |
| { |
| static void apply(Is& out, T& arg) { out >> arg; } |
| }; |
| |
| /// \cond show_operators |
| |
| |
| template<class Base, class Is, class T> |
| struct concept_interface<istreamable<Is, T>, Base, Is> : Base |
| { |
| friend typename detail::non_const_this_param<Base>::type& |
| operator>>(typename detail::non_const_this_param<Base>::type& lhs, |
| typename ::boost::type_erasure::as_param<Base, T&>::type rhs) |
| { |
| ::boost::type_erasure::call(istreamable<Is, T>(), lhs, rhs); |
| return lhs; |
| } |
| }; |
| |
| template<class Base, class Is, class T> |
| struct concept_interface< |
| istreamable<Is, T>, |
| Base, |
| T, |
| typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<Is> >::type |
| > : Base |
| { |
| friend Is& |
| operator>>(Is& lhs, |
| typename ::boost::type_erasure::derived<Base>::type& rhs) |
| { |
| ::boost::type_erasure::call(istreamable<Is, T>(), lhs, rhs); |
| return lhs; |
| } |
| }; |
| |
| /// \endcond |
| |
| } |
| } |
| |
| #endif |
