?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/adapted.tar
???????
boost_tuple/mpl/clear.hpp 0000644 00000001333 15125731317 0011477 0 ustar 00 /*============================================================================= Copyright (c) 2012 Kohei Takahashi 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CLEAR_10172012_0100) #define BOOST_FUSION_CLEAR_10172012_0100 #include <boost/mpl/identity.hpp> #include <boost/fusion/adapted/boost_tuple/tag_of.hpp> namespace boost { namespace fusion { namespace detail { template <typename Tag> struct clear; template <> struct clear<boost_tuple_tag> : mpl::identity<boost::tuple<> > {}; }}} #endif boost_tuple/tag_of.hpp 0000644 00000006000 15125731317 0011054 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_TAG_OF_09262006_1900) #define BOOST_FUSION_TAG_OF_09262006_1900 #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/tag_of_fwd.hpp> namespace boost { namespace tuples { struct null_type; template < class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > class tuple; template <class Head, class Tail> struct cons; }} namespace boost { namespace fusion { struct boost_tuple_tag; struct fusion_sequence_tag; namespace traits { template < class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > #if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) struct tag_of<tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, void > #else struct tag_of<tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> > #endif { typedef boost_tuple_tag type; }; template <class Head, class Tail> #if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) struct tag_of<tuples::cons<Head, Tail>, void > #else struct tag_of<tuples::cons<Head, Tail> > #endif { typedef boost_tuple_tag type; }; template <> struct tag_of<tuples::null_type> { typedef boost_tuple_tag type; }; } }} namespace boost { namespace mpl { template<typename> struct sequence_tag; template < class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > struct sequence_tag<tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> > { typedef fusion::fusion_sequence_tag type; }; template < class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 > struct sequence_tag< tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> const > { typedef fusion::fusion_sequence_tag type; }; template <class Head, class Tail> struct sequence_tag<tuples::cons<Head, Tail> > { typedef fusion::fusion_sequence_tag type; }; template <class Head, class Tail> struct sequence_tag<tuples::cons<Head, Tail> const> { typedef fusion::fusion_sequence_tag type; }; template <> struct sequence_tag<tuples::null_type> { typedef fusion::fusion_sequence_tag type; }; template <> struct sequence_tag<tuples::null_type const> { typedef fusion::fusion_sequence_tag type; }; }} #endif boost_tuple/boost_tuple_iterator.hpp 0000644 00000014444 15125731317 0014100 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(FUSION_BOOST_TUPLE_ITERATOR_09262006_1851) #define FUSION_BOOST_TUPLE_ITERATOR_09262006_1851 #include <boost/fusion/support/config.hpp> #include <boost/fusion/iterator/iterator_facade.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/mpl/identity.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/or.hpp> #include <boost/mpl/plus.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/apply.hpp> #include <boost/tuple/tuple.hpp> namespace boost { namespace fusion { struct forward_traversal_tag; namespace detail { template <typename T> struct boost_tuple_is_empty : mpl::false_ {}; template <> struct boost_tuple_is_empty<tuples::null_type> : mpl::true_ {}; template <> struct boost_tuple_is_empty<tuples::null_type const> : mpl::true_ {}; template <> struct boost_tuple_is_empty<tuples::tuple<> > : mpl::true_ {}; template <> struct boost_tuple_is_empty<tuples::tuple<> const> : mpl::true_ {}; } template <typename Cons> struct boost_tuple_iterator_identity; template <typename Cons = tuples::null_type> struct boost_tuple_iterator : iterator_facade<boost_tuple_iterator<Cons>, forward_traversal_tag> { typedef Cons cons_type; typedef boost_tuple_iterator_identity< typename add_const<Cons>::type> identity; BOOST_FUSION_GPU_ENABLED explicit boost_tuple_iterator(Cons& in_cons) : cons(in_cons) {} Cons& cons; template <typename Iterator> struct value_of : mpl::identity<typename Iterator::cons_type::head_type> {}; template <typename Iterator> struct deref { typedef typename value_of<Iterator>::type element; typedef typename mpl::if_< is_const<typename Iterator::cons_type> , typename tuples::access_traits<element>::const_type , typename tuples::access_traits<element>::non_const_type >::type type; BOOST_FUSION_GPU_ENABLED static type call(Iterator const& iter) { return iter.cons.get_head(); } }; template <typename Iterator> struct next { typedef typename Iterator::cons_type cons_type; typedef typename cons_type::tail_type tail_type; typedef boost_tuple_iterator< typename mpl::eval_if< is_const<cons_type> , add_const<tail_type> , mpl::identity<tail_type> >::type> type; BOOST_FUSION_GPU_ENABLED static type call(Iterator const& iter) { return type(iter.cons.get_tail()); } }; template <typename I1, typename I2> struct distance; // detail template <typename I1, typename I2> struct lazy_next_distance { typedef typename mpl::plus< mpl::int_<1>, typename distance< typename next<I1>::type, I2 >::type >::type type; }; template <typename I1, typename I2> struct distance { typedef typename mpl::eval_if< boost::is_same<I1, I2>, mpl::int_<0>, lazy_next_distance<I1, I2> >::type type; BOOST_FUSION_GPU_ENABLED static type call(I1 const&, I2 const&) { return type(); } }; template <typename I1, typename I2> struct equal_to : is_same<typename I1::identity, typename I2::identity> {}; // silence MSVC warning C4512: assignment operator could not be generated BOOST_DELETED_FUNCTION(boost_tuple_iterator& operator= (boost_tuple_iterator const&)) }; template <typename Null> struct boost_tuple_null_iterator : iterator_facade<boost_tuple_iterator<Null>, forward_traversal_tag> { typedef Null cons_type; typedef boost_tuple_iterator_identity< typename add_const<Null>::type> identity; template <typename I1, typename I2> struct equal_to : mpl::or_< is_same<I1, I2> , mpl::and_< detail::boost_tuple_is_empty<typename I1::cons_type> , detail::boost_tuple_is_empty<typename I2::cons_type> > > {}; }; template <> struct boost_tuple_iterator<tuples::null_type> : boost_tuple_null_iterator<tuples::null_type> { template <typename Cons> BOOST_FUSION_GPU_ENABLED explicit boost_tuple_iterator(Cons const&) {} }; template <> struct boost_tuple_iterator<tuples::null_type const> : boost_tuple_null_iterator<tuples::null_type const> { template <typename Cons> BOOST_FUSION_GPU_ENABLED explicit boost_tuple_iterator(Cons const&) {} }; template <> struct boost_tuple_iterator<tuples::tuple<> > : boost_tuple_null_iterator<tuples::tuple<> > { template <typename Cons> BOOST_FUSION_GPU_ENABLED explicit boost_tuple_iterator(Cons const&) {} }; template <> struct boost_tuple_iterator<tuples::tuple<> const> : boost_tuple_null_iterator<tuples::tuple<> const> { template <typename Cons> BOOST_FUSION_GPU_ENABLED explicit boost_tuple_iterator(Cons const&) {} }; }} #ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408 namespace std { template <typename Cons> struct iterator_traits< ::boost::fusion::boost_tuple_iterator<Cons> > { }; } #endif #endif boost_tuple/detail/end_impl.hpp 0000644 00000003037 15125731317 0012655 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_END_IMPL_09272006_0721) #define BOOST_FUSION_END_IMPL_09272006_0721 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/boost_tuple/boost_tuple_iterator.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/is_const.hpp> namespace boost { namespace tuples { struct null_type; }} namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template <typename Tag> struct end_impl; template <> struct end_impl<boost_tuple_tag> { template <typename Sequence> struct apply { typedef boost_tuple_iterator< typename mpl::if_< is_const<Sequence> , tuples::null_type const , tuples::null_type >::type > type; BOOST_FUSION_GPU_ENABLED static type call(Sequence& seq) { return type(seq); } }; }; } }} #endif boost_tuple/detail/at_impl.hpp 0000644 00000003025 15125731317 0012510 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_AT_IMPL_09262006_1920) #define BOOST_FUSION_AT_IMPL_09262006_1920 #include <boost/fusion/support/config.hpp> #include <boost/tuple/tuple.hpp> #include <boost/mpl/if.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template<typename T> struct at_impl; template <> struct at_impl<boost_tuple_tag> { template <typename Sequence, typename N> struct apply { typedef typename tuples::element<N::value, Sequence>::type element; typedef typename mpl::if_< is_const<Sequence> , typename tuples::access_traits<element>::const_type , typename tuples::access_traits<element>::non_const_type >::type type; BOOST_FUSION_GPU_ENABLED static type call(Sequence& seq) { return tuples::get<N::value>(seq); } }; }; } }} #endif boost_tuple/detail/build_cons.hpp 0000644 00000003444 15125731317 0013211 0 ustar 00 /*============================================================================= Copyright (c) 2012-2014 Kohei Takahashi 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BUILD_CONS_10172012_0130) #define BOOST_FUSION_BUILD_CONS_10172012_0130 #include <boost/tuple/tuple.hpp> #include <boost/fusion/iterator/equal_to.hpp> #include <boost/fusion/iterator/next.hpp> #include <boost/fusion/iterator/value_of.hpp> #include <boost/fusion/iterator/deref.hpp> namespace boost { namespace fusion { namespace detail { template < typename First , typename Last , bool is_empty = result_of::equal_to<First, Last>::value> struct build_tuple_cons; template <typename First, typename Last> struct build_tuple_cons<First, Last, true> { typedef boost::tuples::null_type type; BOOST_FUSION_GPU_ENABLED static type call(First const&, Last const&) { return type(); } }; template <typename First, typename Last> struct build_tuple_cons<First, Last, false> { typedef build_tuple_cons<typename result_of::next<First>::type, Last> next_build_tuple_cons; typedef boost::tuples::cons< typename result_of::value_of<First>::type , typename next_build_tuple_cons::type> type; BOOST_FUSION_GPU_ENABLED static type call(First const& f, Last const& l) { typename result_of::value_of<First>::type v = *f; return type(v, next_build_tuple_cons::call(fusion::next(f), l)); } }; }}} #endif boost_tuple/detail/convert_impl.hpp 0000644 00000003055 15125731317 0013567 0 ustar 00 /*============================================================================= Copyright (c) 2012-2014 Kohei Takahashi 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CONVERT_IMPL_10172012_0120) #define BOOST_FUSION_CONVERT_IMPL_10172012_0120 #include <boost/tuple/tuple.hpp> #include <boost/fusion/adapted/boost_tuple/detail/build_cons.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/sequence/intrinsic/end.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template <typename T> struct convert_impl; template <> struct convert_impl<boost_tuple_tag> { template <typename Sequence> struct apply { typedef typename detail::build_tuple_cons< typename result_of::begin<Sequence>::type , typename result_of::end<Sequence>::type > build_tuple_cons; typedef typename build_tuple_cons::type type; BOOST_FUSION_GPU_ENABLED static type call(Sequence& seq) { return build_tuple_cons::call(fusion::begin(seq), fusion::end(seq)); } }; }; } }} #endif boost_tuple/detail/value_at_impl.hpp 0000644 00000001633 15125731317 0013707 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_VALUE_AT_IMPL_09262006_1926) #define BOOST_FUSION_VALUE_AT_IMPL_09262006_1926 #include <boost/fusion/support/config.hpp> #include <boost/tuple/tuple.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template<typename T> struct value_at_impl; template <> struct value_at_impl<boost_tuple_tag> { template <typename Sequence, typename N> struct apply : tuples::element<N::value, Sequence> {}; }; } }} #endif boost_tuple/detail/begin_impl.hpp 0000644 00000002215 15125731317 0013170 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BEGIN_IMPL_09272006_0719) #define BOOST_FUSION_BEGIN_IMPL_09272006_0719 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/boost_tuple/boost_tuple_iterator.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template<typename T> struct begin_impl; template <> struct begin_impl<boost_tuple_tag> { template <typename Sequence> struct apply { typedef boost_tuple_iterator<Sequence> type; BOOST_FUSION_GPU_ENABLED static type call(Sequence& v) { return type(v); } }; }; } }} #endif boost_tuple/detail/size_impl.hpp 0000644 00000001644 15125731317 0013063 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_SIZE_IMPL_09272006_0724) #define BOOST_FUSION_SIZE_IMPL_09272006_0724 #include <boost/fusion/support/config.hpp> #include <boost/tuple/tuple.hpp> #include <boost/mpl/int.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template<typename T> struct size_impl; template <> struct size_impl<boost_tuple_tag> { template <typename Sequence> struct apply : mpl::int_<tuples::length<Sequence>::value> {}; }; } }} #endif boost_tuple/detail/is_sequence_impl.hpp 0000644 00000001600 15125731317 0014404 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_SEQUENCE_IMPL_09272006_0726) #define BOOST_FUSION_IS_SEQUENCE_IMPL_09272006_0726 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template<typename Tag> struct is_sequence_impl; template<> struct is_sequence_impl<boost_tuple_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; } }} #endif boost_tuple/detail/is_view_impl.hpp 0000644 00000001552 15125731317 0013554 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_VIEW_IMPL_09272006_0725) #define BOOST_FUSION_IS_VIEW_IMPL_09272006_0725 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct boost_tuple_tag; namespace extension { template<typename Tag> struct is_view_impl; template<> struct is_view_impl<boost_tuple_tag> { template<typename T> struct apply : mpl::false_ {}; }; } }} #endif boost_tuple/detail/category_of_impl.hpp 0000644 00000001620 15125731317 0014404 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CATEGORY_OF_IMPL_09272006_0726) #define BOOST_FUSION_CATEGORY_OF_IMPL_09272006_0726 namespace boost { namespace fusion { struct boost_tuple_tag; struct forward_traversal_tag; namespace extension { template<typename T> struct category_of_impl; template<> struct category_of_impl<boost_tuple_tag> { template<typename T> struct apply { typedef forward_traversal_tag type; }; }; } }} #endif mpl/mpl_iterator.hpp 0000644 00000006757 15125731317 0010572 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(FUSION_MPL_ITERATOR_05052005_0731) #define FUSION_MPL_ITERATOR_05052005_0731 #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/detail/mpl_iterator_category.hpp> #include <boost/fusion/iterator/iterator_facade.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/mpl/deref.hpp> #include <boost/mpl/next.hpp> #include <boost/mpl/prior.hpp> #include <boost/mpl/advance.hpp> #include <boost/mpl/distance.hpp> namespace boost { namespace fusion { template <typename Iterator_> struct mpl_iterator : iterator_facade< mpl_iterator<Iterator_> , typename detail::mpl_iterator_category<typename Iterator_::category>::type > { typedef typename remove_const<Iterator_>::type iterator_type; template <typename Iterator> struct value_of : mpl::deref<typename Iterator::iterator_type> {}; template <typename Iterator> struct deref { typedef typename mpl::deref< typename Iterator::iterator_type>::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator) { return type(); } }; template <typename Iterator> struct next { typedef mpl_iterator< typename mpl::next<typename Iterator::iterator_type>::type> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator) { return type(); } }; template <typename Iterator> struct prior { typedef mpl_iterator< typename mpl::prior<typename Iterator::iterator_type>::type> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator) { return type(); } }; template <typename Iterator, typename N> struct advance { typedef mpl_iterator< typename mpl::advance<typename Iterator::iterator_type, N>::type> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator const& /*i*/) { return type(); } }; template <typename I1, typename I2> struct distance : mpl::distance< typename I1::iterator_type , typename I2::iterator_type> { typedef typename mpl::distance< typename I1::iterator_type , typename I2::iterator_type >::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(I1 const&, I2 const&) { return type(); } }; }; }} #ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408 namespace std { template <typename Iterator> struct iterator_traits< ::boost::fusion::mpl_iterator<Iterator> > { }; } #endif #endif mpl/detail/end_impl.hpp 0000644 00000002577 15125731317 0011116 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_END_IMPL_31122005_1237) #define BOOST_FUSION_END_IMPL_31122005_1237 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/mpl/mpl_iterator.hpp> #include <boost/mpl/end.hpp> #include <boost/type_traits/add_const.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template <typename Tag> struct end_impl; template <> struct end_impl<mpl_sequence_tag> { template <typename Sequence> struct apply { typedef typename mpl::end< typename remove_const<Sequence>::type >::type iterator; typedef mpl_iterator<iterator> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence) { return type(); } }; }; } }} #endif mpl/detail/at_impl.hpp 0000644 00000002254 15125731317 0010744 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_AT_IMPL_31122005_1642) #define BOOST_FUSION_AT_IMPL_31122005_1642 #include <boost/fusion/support/config.hpp> #include <boost/mpl/at.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template<typename Tag> struct at_impl; template <> struct at_impl<mpl_sequence_tag> { template <typename Sequence, typename N> struct apply { typedef typename mpl::at<Sequence, N>::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence) { return type(); } }; }; } }} #endif mpl/detail/has_key_impl.hpp 0000644 00000001677 15125731317 0011773 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_HAS_KEY_IMPL_31122005_1647) #define BOOST_FUSION_HAS_KEY_IMPL_31122005_1647 #include <boost/fusion/support/config.hpp> #include <boost/mpl/has_key.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template <typename Tag> struct has_key_impl; template <> struct has_key_impl<mpl_sequence_tag> { template <typename Sequence, typename Key> struct apply : mpl::has_key<Sequence, Key> {}; }; } }} #endif mpl/detail/value_at_impl.hpp 0000644 00000001665 15125731317 0012145 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_VALUE_AT_IMPL_31122005_1621) #define BOOST_FUSION_VALUE_AT_IMPL_31122005_1621 #include <boost/fusion/support/config.hpp> #include <boost/mpl/at.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template <typename Tag> struct value_at_impl; template <> struct value_at_impl<mpl_sequence_tag> { template <typename Sequence, typename N> struct apply : mpl::at<Sequence, N> {}; }; } }} #endif mpl/detail/begin_impl.hpp 0000644 00000002624 15125731317 0011425 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BEGIN_IMPL_31122005_1209) #define BOOST_FUSION_BEGIN_IMPL_31122005_1209 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/mpl/mpl_iterator.hpp> #include <boost/mpl/begin.hpp> #include <boost/type_traits/remove_const.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template <typename Tag> struct begin_impl; template <> struct begin_impl<mpl_sequence_tag> { template <typename Sequence> struct apply { typedef typename mpl::begin< typename remove_const<Sequence>::type >::type iterator; typedef mpl_iterator<iterator> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence) { return type(); } }; }; } }} #endif mpl/detail/empty_impl.hpp 0000644 00000001643 15125731317 0011477 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_EMPTY_IMPL_31122005_1554) #define BOOST_FUSION_EMPTY_IMPL_31122005_1554 #include <boost/fusion/support/config.hpp> #include <boost/mpl/empty.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template <typename Sequence> struct empty_impl; template <> struct empty_impl<mpl_sequence_tag> { template <typename Sequence> struct apply : mpl::empty<Sequence> {}; }; } }} #endif mpl/detail/size_impl.hpp 0000644 00000001631 15125731317 0011310 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_SIZE_IMPL_31122005_1508) #define BOOST_FUSION_SIZE_IMPL_31122005_1508 #include <boost/fusion/support/config.hpp> #include <boost/mpl/size.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template<typename Tag> struct size_impl; template <> struct size_impl<mpl_sequence_tag> { template <typename Sequence> struct apply : mpl::size<Sequence> {}; }; } }} #endif mpl/detail/is_sequence_impl.hpp 0000644 00000001642 15125731317 0012643 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_SEQUENCE_IMPL_31122005_1505) #define BOOST_FUSION_IS_SEQUENCE_IMPL_31122005_1505 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template<typename Tag> struct is_sequence_impl; template<> struct is_sequence_impl<mpl_sequence_tag> { template<typename T> struct apply : mpl::true_ {}; }; } }} #endif mpl/detail/is_view_impl.hpp 0000644 00000001637 15125731317 0012011 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_VIEW_IMPL_03202006_0048) #define BOOST_FUSION_IS_VIEW_IMPL_03202006_0048 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct mpl_sequence_tag; namespace extension { template<typename Tag> struct is_view_impl; template<> struct is_view_impl<mpl_sequence_tag> { template<typename T> struct apply : mpl::true_ {}; }; } }} #endif mpl/detail/category_of_impl.hpp 0000644 00000003150 15125731317 0012635 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CATEGORY_OF_IMPL_20060217_2141) #define BOOST_FUSION_CATEGORY_OF_IMPL_20060217_2141 #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/detail/mpl_iterator_category.hpp> #include <boost/mpl/begin_end.hpp> #include <boost/mpl/is_sequence.hpp> #include <boost/static_assert.hpp> namespace boost { namespace fusion { namespace detail { template <typename T> struct mpl_sequence_category_of { // assumes T is an mpl sequence // there should be no way this will ever be // called where T is an mpl iterator BOOST_STATIC_ASSERT(mpl::is_sequence<T>::value); typedef typename mpl_iterator_category< typename mpl::begin<T>::type::category >::type type; }; } struct mpl_sequence_tag; namespace extension { template<typename Tag> struct category_of_impl; template<> struct category_of_impl<mpl_sequence_tag> { template<typename T> struct apply : detail::mpl_sequence_category_of<T> {}; }; } }} #endif boost_tuple.hpp 0000644 00000007006 15125731317 0007624 0 ustar 00 // Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2008-2012 Bruno Lalande, Paris, France. // Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2009-2012 Mateusz Loskot, London, UK. // This file was modified by Oracle on 2018-2020. // Modifications copyright (c) 2018-2020, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is subject to 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_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_TUPLE_HPP #define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_TUPLE_HPP #include <cstddef> #include <type_traits> #include <boost/tuple/tuple.hpp> #include <boost/geometry/core/access.hpp> #include <boost/geometry/core/coordinate_dimension.hpp> #include <boost/geometry/core/coordinate_type.hpp> #include <boost/geometry/core/point_type.hpp> #include <boost/geometry/core/tags.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS namespace traits { template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> struct tag<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> > { typedef point_tag type; }; template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> struct coordinate_type<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> > { typedef T1 type; }; template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> struct dimension<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> > : std::integral_constant < std::size_t, boost::tuples::length < boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >::value > {}; template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, std::size_t Dimension> struct access < boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, Dimension > { static inline T1 get( boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> const& point) { return point.template get<Dimension>(); } static inline void set( boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& point, T1 const& value) { point.template get<Dimension>() = value; } }; } // namespace traits #endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS }} // namespace boost::geometry // Convenience registration macro to bind boost::tuple to a CS #define BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(CoordinateSystem) \ namespace boost { namespace geometry { namespace traits { \ template <typename T1, typename T2, typename T3, typename T4, typename T5, \ typename T6, typename T7, typename T8, typename T9, typename T10> \ struct coordinate_system<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> > \ { \ typedef CoordinateSystem type; \ }; \ }}} #endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_TUPLE_HPP array.hpp 0000644 00000002275 15125731317 0006406 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2010 Christopher Schmidt 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) ==============================================================================*/ #if !defined(BOOST_FUSION_ARRAY_27122005_1035) #define BOOST_FUSION_ARRAY_27122005_1035 //For backwards compatibility #include <boost/fusion/adapted/boost_array.hpp> #include <boost/fusion/adapted/array/tag_of.hpp> #include <boost/fusion/adapted/array/is_view_impl.hpp> #include <boost/fusion/adapted/array/is_sequence_impl.hpp> #include <boost/fusion/adapted/array/category_of_impl.hpp> #include <boost/fusion/adapted/array/begin_impl.hpp> #include <boost/fusion/adapted/array/end_impl.hpp> #include <boost/fusion/adapted/array/size_impl.hpp> #include <boost/fusion/adapted/array/at_impl.hpp> #include <boost/fusion/adapted/array/value_at_impl.hpp> #include <boost/fusion/adapted/array/deref_impl.hpp> #include <boost/fusion/adapted/array/value_of_impl.hpp> #endif std_array.hpp 0000644 00000006271 15125731317 0007260 0 ustar 00 // Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2010 Alfredo Correa // Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2016 Norbert Wenzel // This file was modified by Oracle on 2020. // Modifications copyright (c) 2020, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Use, modification and distribution is subject to 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_GEOMETRY_GEOMETRIES_ADAPTED_STD_ARRAY_HPP #define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_ARRAY_HPP #include <boost/config.hpp> #ifndef BOOST_NO_CXX11_HDR_ARRAY #define BOOST_GEOMETRY_ADAPTED_STD_ARRAY_TAG_DEFINED #include <array> #include <cstddef> #include <type_traits> #include <boost/geometry/core/access.hpp> #include <boost/geometry/core/cs.hpp> #include <boost/geometry/core/coordinate_dimension.hpp> #include <boost/geometry/core/coordinate_type.hpp> #include <boost/geometry/core/tags.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS namespace traits { #ifndef DOXYGEN_NO_DETAIL namespace detail { // Create class and specialization to indicate the tag // for normal cases and the case that the type of the std-array is arithmetic template <bool> struct std_array_tag { typedef geometry_not_recognized_tag type; }; template <> struct std_array_tag<true> { typedef point_tag type; }; } // namespace detail #endif // DOXYGEN_NO_DETAIL // Assign the point-tag, preventing arrays of points getting a point-tag template <typename CoordinateType, std::size_t DimensionCount> struct tag<std::array<CoordinateType, DimensionCount> > : detail::std_array_tag<std::is_arithmetic<CoordinateType>::value> {}; template <typename CoordinateType, std::size_t DimensionCount> struct coordinate_type<std::array<CoordinateType, DimensionCount> > { typedef CoordinateType type; }; template <typename CoordinateType, std::size_t DimensionCount> struct dimension<std::array<CoordinateType, DimensionCount> > : std::integral_constant<std::size_t, DimensionCount> {}; template <typename CoordinateType, std::size_t DimensionCount, std::size_t Dimension> struct access<std::array<CoordinateType, DimensionCount>, Dimension> { static inline CoordinateType get(std::array<CoordinateType, DimensionCount> const& a) { return a[Dimension]; } static inline void set(std::array<CoordinateType, DimensionCount>& a, CoordinateType const& value) { a[Dimension] = value; } }; } // namespace traits #endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS }} // namespace boost::geometry #define BOOST_GEOMETRY_REGISTER_STD_ARRAY_CS(CoordinateSystem) \ namespace boost { namespace geometry { namespace traits { \ template <class T, std::size_t N> \ struct coordinate_system<std::array<T, N> > \ { \ typedef CoordinateSystem type; \ }; \ }}} #else #warning "This file requires compiler and library support for the ISO C++ 2011 standard." #endif // BOOST_NO_CXX11_HDR_ARRAY #endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_ARRAY_HPP array/end_impl.hpp 0000644 00000002444 15125731317 0010173 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_END_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_END_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/iterator/basic_iterator.hpp> #include <boost/type_traits/rank.hpp> #include <boost/type_traits/extent.hpp> namespace boost { namespace fusion { namespace extension { template <typename> struct end_impl; template <> struct end_impl<po_array_tag> { template <typename Seq> struct apply { typedef basic_iterator< po_array_iterator_tag , random_access_traversal_tag , Seq , extent<Seq,rank<Seq>::value-1>::value > type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return type(seq,0); } }; }; }}} #endif array/at_impl.hpp 0000644 00000002171 15125731317 0010026 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_AT_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_AT_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/remove_extent.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct at_impl; template<> struct at_impl<po_array_tag> { template<typename Seq, typename N> struct apply { typedef typename add_reference<typename remove_extent<Seq>::type>::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return seq[N::value]; } }; }; }}} #endif array/value_at_impl.hpp 0000644 00000001531 15125731317 0011221 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_VALUE_AT_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_VALUE_AT_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/type_traits/remove_extent.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct value_at_impl; template <> struct value_at_impl<po_array_tag> { template <typename Seq, typename N> struct apply : remove_extent<Seq> {}; }; }}} #endif array/tag_of.hpp 0000644 00000003607 15125731317 0007645 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_TAG_OF_HPP #define BOOST_FUSION_ADAPTED_ARRAY_TAG_OF_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/tag_of_fwd.hpp> #include <cstddef> namespace boost { namespace fusion { struct po_array_tag; struct po_array_iterator_tag; struct random_access_traversal_tag; struct fusion_sequence_tag; namespace traits { #ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS template<typename T, std::size_t N> struct tag_of<T[N], void> { typedef po_array_tag type; }; template<typename T, std::size_t N> struct tag_of<T const[N], void> { typedef po_array_tag type; }; #else template<typename T, std::size_t N> struct tag_of<T[N], void> { typedef po_array_tag type; }; template<typename T, std::size_t N> struct tag_of<T const[N], void> { typedef po_array_tag type; }; #endif } } namespace mpl { template<typename> struct sequence_tag; template<typename T, std::size_t N> struct sequence_tag<T[N]> { typedef fusion::po_array_tag type; }; template<typename T, std::size_t N> struct sequence_tag<T const[N] > { typedef fusion::po_array_tag type; }; } } #endif array/deref_impl.hpp 0000644 00000002315 15125731317 0010507 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_DEREF_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_DEREF_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/remove_extent.hpp> namespace boost { namespace fusion { namespace extension { template <typename> struct deref_impl; template <> struct deref_impl<po_array_iterator_tag> { template <typename It> struct apply { typedef typename add_reference< typename remove_extent<typename It::seq_type>::type >::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(It const& it) { return (*it.seq)[It::index::value]; } }; }; }}} #endif array/begin_impl.hpp 0000644 00000002271 15125731320 0010501 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_BEGIN_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_BEGIN_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/iterator/basic_iterator.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct begin_impl; template <> struct begin_impl<po_array_tag> { template <typename Seq> struct apply { typedef basic_iterator< po_array_iterator_tag , random_access_traversal_tag , Seq , 0 > type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return type(seq,0); } }; }; }}} #endif array/size_impl.hpp 0000644 00000001545 15125731320 0010372 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_SIZE_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_SIZE_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/type_traits/rank.hpp> #include <boost/type_traits/extent.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct size_impl; template<> struct size_impl<po_array_tag> { template<typename Seq> struct apply : extent<Seq,rank<Seq>::value-1> {}; }; }}} #endif array/value_of_impl.hpp 0000644 00000001547 15125731320 0011222 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_VALUE_OF_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_VALUE_OF_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/type_traits/remove_extent.hpp> namespace boost { namespace fusion { namespace extension { template <typename> struct value_of_impl; template <> struct value_of_impl<po_array_iterator_tag> { template <typename It> struct apply : remove_extent<typename It::seq_type> {}; }; }}} #endif array/is_sequence_impl.hpp 0000644 00000001476 15125731320 0011726 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_IS_SEQUENCE_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_IS_SEQUENCE_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct is_sequence_impl; template<> struct is_sequence_impl<po_array_tag> { template<typename Seq> struct apply : mpl::true_ {}; }; }}} #endif array/is_view_impl.hpp 0000644 00000001457 15125731320 0011067 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_IS_VIEW_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_IS_VIEW_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct is_view_impl; template<> struct is_view_impl<po_array_tag> { template<typename Seq> struct apply : mpl::false_ {}; }; }}} #endif array/category_of_impl.hpp 0000644 00000001576 15125731320 0011725 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ARRAY_CATEGORY_OF_IMPL_HPP #define BOOST_FUSION_ADAPTED_ARRAY_CATEGORY_OF_IMPL_HPP namespace boost { namespace fusion { struct random_access_traversal_tag; namespace extension { template<typename> struct category_of_impl; template<> struct category_of_impl<po_array_tag> { template<typename Seq> struct apply { typedef random_access_traversal_tag type; }; }; } }} #endif struct/adapt_struct.hpp 0000644 00000016106 15125731320 0011301 0 ustar 00 /*============================================================================= Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2009-2011 Christopher Schmidt Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_HPP #include <boost/fusion/support/config.hpp> #include <boost/preprocessor/config/config.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/empty.hpp> #include <boost/preprocessor/control/iif.hpp> #include <boost/preprocessor/comparison/less.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/variadic/to_seq.hpp> #include <boost/fusion/adapted/struct/detail/extension.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base_attr_filler.hpp> #include <boost/fusion/adapted/struct/detail/at_impl.hpp> #include <boost/fusion/adapted/struct/detail/is_view_impl.hpp> #include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_at_impl.hpp> #include <boost/fusion/adapted/struct/detail/category_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/size_impl.hpp> #include <boost/fusion/adapted/struct/detail/begin_impl.hpp> #include <boost/fusion/adapted/struct/detail/end_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_impl.hpp> #define BOOST_FUSION_ADAPT_STRUCT_C( \ TEMPLATE_PARAMS_SEQ, NAME_SEQ, IS_VIEW, I, ATTRIBUTE) \ BOOST_FUSION_ADAPT_STRUCT_C_BASE( \ TEMPLATE_PARAMS_SEQ, \ NAME_SEQ, \ IS_VIEW, \ I, \ BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY), \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE), \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), \ BOOST_PP_LESS( \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), 2)) #if BOOST_PP_VARIADICS # define BOOST_FUSION_ADAPT_TPL_STRUCT(TEMPLATE_PARAMS_SEQ,NAME_SEQ, ...) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (1)TEMPLATE_PARAMS_SEQ, \ (1)NAME_SEQ, \ struct_tag, \ 0, \ BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER( \ BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)), \ BOOST_FUSION_ADAPT_STRUCT_C) # define BOOST_FUSION_ADAPT_STRUCT(...) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(BOOST_PP_SEQ_HEAD(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))), \ struct_tag, \ 0, \ BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER( \ BOOST_PP_SEQ_TAIL(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))), \ BOOST_FUSION_ADAPT_STRUCT_C) # define BOOST_FUSION_ADAPT_STRUCT_AS_VIEW(...) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(BOOST_PP_SEQ_HEAD(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))), \ struct_tag, \ 1, \ BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER( \ BOOST_PP_SEQ_TAIL(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))), \ BOOST_FUSION_ADAPT_STRUCT_C) #else // BOOST_PP_VARIADICS # define BOOST_FUSION_ADAPT_TPL_STRUCT( \ TEMPLATE_PARAMS_SEQ,NAME_SEQ, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (1)TEMPLATE_PARAMS_SEQ, \ (1)NAME_SEQ, \ struct_tag, \ 0, \ BOOST_PP_CAT( \ BOOST_FUSION_ADAPT_STRUCT_FILLER_0(0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_STRUCT_C) # define BOOST_FUSION_ADAPT_STRUCT(NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(NAME), \ struct_tag, \ 0, \ BOOST_PP_CAT( \ BOOST_FUSION_ADAPT_STRUCT_FILLER_0(0,0)ATTRIBUTES, \ _END), \ BOOST_FUSION_ADAPT_STRUCT_C) # define BOOST_FUSION_ADAPT_STRUCT_AS_VIEW(NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(NAME), \ struct_tag, \ 1, \ BOOST_PP_CAT( \ BOOST_FUSION_ADAPT_STRUCT_FILLER_0(0,0)ATTRIBUTES, \ _END), \ BOOST_FUSION_ADAPT_STRUCT_C) #endif // BOOST_PP_VARIADICS #endif struct/define_assoc_struct.hpp 0000644 00000006157 15125731320 0012637 0 ustar 00 /*============================================================================= Copyright (c) 2010-2011 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DEFINE_ASSOC_STRUCT_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DEFINE_ASSOC_STRUCT_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp> #include <boost/fusion/adapted/struct/detail/define_struct.hpp> #include <boost/preprocessor/cat.hpp> #define BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_0(X, Y, Z) \ ((X, Y, Z)) BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_1 #define BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_1(X, Y, Z) \ ((X, Y, Z)) BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_0 #define BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_0_END #define BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_1_END #define BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT( \ TEMPLATE_PARAMS_SEQ, NAMESPACE_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_DEFINE_TPL_STRUCT_IMPL( \ TEMPLATE_PARAMS_SEQ, \ (0)NAMESPACE_SEQ, \ NAME, \ BOOST_PP_CAT( \ BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_0(0,0,0)ATTRIBUTES,_END), \ 3) \ \ BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT( \ TEMPLATE_PARAMS_SEQ, \ (BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ) NAME)\ TEMPLATE_PARAMS_SEQ, \ ATTRIBUTES) #define BOOST_FUSION_DEFINE_ASSOC_STRUCT(NAMESPACE_SEQ, NAME, ATTRIBUTES) \ BOOST_FUSION_DEFINE_STRUCT_IMPL( \ (0)NAMESPACE_SEQ, \ NAME, \ BOOST_PP_CAT( \ BOOST_FUSION_DEFINE_ASSOC_STRUCT_FILLER_0(0,0,0)ATTRIBUTES,_END), \ 3) \ \ BOOST_FUSION_ADAPT_ASSOC_STRUCT( \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ) NAME, \ ATTRIBUTES) #endif struct/define_struct_inline.hpp 0000644 00000002465 15125731320 0013003 0 ustar 00 /*============================================================================= Copyright (c) 2012 Nathan Ridge 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_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_INLINE_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_INLINE_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_struct.hpp> #include <boost/fusion/adapted/struct/detail/define_struct_inline.hpp> #define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL( \ TEMPLATE_PARAMS_SEQ, \ NAME, \ ATTRIBUTES) #define BOOST_FUSION_DEFINE_STRUCT_INLINE(NAME, ATTRIBUTES) \ BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES) \ #endif struct/define_struct.hpp 0000644 00000005064 15125731320 0011443 0 ustar 00 /*============================================================================= Copyright (c) 2010-2011 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_struct.hpp> #include <boost/fusion/adapted/struct/detail/define_struct.hpp> #include <boost/preprocessor/cat.hpp> #define BOOST_FUSION_DEFINE_TPL_STRUCT( \ TEMPLATE_PARAMS_SEQ, NAMESPACE_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_DEFINE_TPL_STRUCT_IMPL( \ TEMPLATE_PARAMS_SEQ, \ (0)NAMESPACE_SEQ, \ NAME, \ BOOST_PP_CAT(BOOST_FUSION_DEFINE_STRUCT_FILLER_0(0,0)ATTRIBUTES,_END), \ 2) \ \ BOOST_FUSION_ADAPT_TPL_STRUCT( \ TEMPLATE_PARAMS_SEQ, \ (BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ) NAME)\ TEMPLATE_PARAMS_SEQ, \ ATTRIBUTES) #define BOOST_FUSION_DEFINE_STRUCT(NAMESPACE_SEQ, NAME, ATTRIBUTES) \ BOOST_FUSION_DEFINE_STRUCT_IMPL( \ (0)NAMESPACE_SEQ, \ NAME, \ BOOST_PP_CAT(BOOST_FUSION_DEFINE_STRUCT_FILLER_0(0,0)ATTRIBUTES,_END), \ 2) \ \ BOOST_FUSION_ADAPT_STRUCT( \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ) NAME, \ ATTRIBUTES) #endif struct/detail/key_of_impl.hpp 0000644 00000001601 15125731320 0012335 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_KEY_OF_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_KEY_OF_IMPL_HPP namespace boost { namespace fusion { namespace extension { template <typename> struct key_of_impl; template <> struct key_of_impl<struct_iterator_tag> { template <typename It> struct apply : extension::struct_assoc_key< typename remove_const<typename It::seq_type>::type , It::index::value > {}; }; }}} #endif struct/detail/end_impl.hpp 0000644 00000003612 15125731320 0011633 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_END_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/iterator/basic_iterator.hpp> namespace boost { namespace fusion { namespace extension { template <typename> struct end_impl; template <> struct end_impl<struct_tag> { template <typename Seq> struct apply { typedef basic_iterator< struct_iterator_tag , random_access_traversal_tag , Seq , struct_size<typename remove_const<Seq>::type>::value > type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return type(seq,0); } }; }; template <> struct end_impl<assoc_struct_tag> { template <typename Seq> struct apply { typedef basic_iterator< struct_iterator_tag , assoc_struct_category , Seq , struct_size<typename remove_const<Seq>::type>::value > type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return type(seq,0); } }; }; }}} #endif struct/detail/deref_data_impl.hpp 0000644 00000001331 15125731320 0013137 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_DATA_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_DATA_IMPL_HPP namespace boost { namespace fusion { namespace extension { template <typename> struct deref_data_impl; template <> struct deref_data_impl<struct_iterator_tag> : deref_impl<struct_iterator_tag> {}; }}} #endif struct/detail/adapt_base.hpp 0000644 00000051232 15125731320 0012130 0 ustar 00 /*============================================================================= Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2011 Christopher Schmidt Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_HPP #include <boost/fusion/support/config.hpp> #include <boost/config.hpp> #include <boost/fusion/support/tag_of_fwd.hpp> #include <boost/fusion/adapted/struct/detail/adapt_auto.hpp> #include <boost/fusion/adapted/struct/detail/adapt_is_tpl.hpp> #include <boost/preprocessor/empty.hpp> #include <boost/preprocessor/stringize.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/seq/for_each_i.hpp> #include <boost/preprocessor/seq/enum.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/tuple/eat.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/comparison/less.hpp> #include <boost/preprocessor/logical/not.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/tag.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/identity.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/typeof/typeof.hpp> #define BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME_TEMPLATE_PARAMS(SEQ) \ BOOST_PP_SEQ_HEAD(SEQ)<BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TAIL(SEQ))> \ BOOST_PP_EMPTY() #define BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(SEQ) \ BOOST_PP_IF( \ BOOST_PP_SEQ_HEAD(SEQ), \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME_TEMPLATE_PARAMS, \ BOOST_PP_SEQ_HEAD)(BOOST_PP_SEQ_TAIL(SEQ)) #define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL_C(R, _, ELEM) \ (typename ELEM) #define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL(SEQ) \ BOOST_PP_SEQ_ENUM( \ BOOST_PP_SEQ_FOR_EACH( \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL_C, \ _, \ BOOST_PP_SEQ_TAIL(SEQ))) #define BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(SEQ) \ BOOST_PP_IF( \ BOOST_PP_SEQ_HEAD(SEQ), \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL, \ BOOST_PP_TUPLE_EAT(1))(SEQ) #ifdef BOOST_MSVC # define BOOST_FUSION_ATTRIBUTE_TYPEOF( \ NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \ \ BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ \ struct deduced_attr_type { \ static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj; \ typedef \ BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ), typename, ) \ BOOST_TYPEOF( PREFIX() obj.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, \ 0, ATTRIBUTE)) \ type; \ }; \ \ typedef \ BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ), typename, ) \ deduced_attr_type::type attribute_type; #else # define BOOST_FUSION_ATTRIBUTE_TYPEOF( \ NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \ \ struct deduced_attr_type { \ static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj; \ typedef BOOST_TYPEOF( \ PREFIX() obj.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE)) \ type; \ }; \ \ typedef \ BOOST_PP_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ), typename, ) \ deduced_attr_type::type attribute_type; #endif #define BOOST_FUSION_ATTRIBUTE_GIVENTYPE( \ NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \ typedef \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE) attribute_type; #ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS # define BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ MODIFIER, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ > \ struct tag_of< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) MODIFIER \ , void \ > \ { \ typedef TAG type; \ }; #else # define BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ MODIFIER, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ > \ struct tag_of<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) MODIFIER> \ { \ typedef TAG type; \ }; #endif #define BOOST_FUSION_ADAPT_STRUCT_BASE_UNPACK_AND_CALL(R,DATA,I,ATTRIBUTE) \ BOOST_PP_TUPLE_ELEM(4,0,DATA)( \ BOOST_PP_TUPLE_ELEM(4,1,DATA), \ BOOST_PP_TUPLE_ELEM(4,2,DATA), \ BOOST_PP_TUPLE_ELEM(4,3,DATA), \ I, \ ATTRIBUTE) #ifdef BOOST_MSVC # define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAM(R,_,ELEM) \ typedef ELEM ELEM; # define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS_IMPL(SEQ) \ BOOST_PP_SEQ_FOR_EACH( \ BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAM, \ _, \ BOOST_PP_SEQ_TAIL(SEQ)) # define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(SEQ) \ BOOST_PP_IF( \ BOOST_PP_SEQ_HEAD(SEQ), \ BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS_IMPL, \ BOOST_PP_TUPLE_EAT(1))(SEQ) #else # define BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(SEQ) #endif #define BOOST_FUSION_ADAPT_STRUCT_C_BASE( \ TEMPLATE_PARAMS_SEQ,NAME_SEQ,IS_VIEW, \ I,PREFIX,ATTRIBUTE,ATTRIBUTE_TUPLE_SIZE, \ DEDUCE_TYPE) \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ > \ struct access::struct_member< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \ , I \ > \ { \ BOOST_PP_IF(DEDUCE_TYPE, \ BOOST_FUSION_ATTRIBUTE_TYPEOF, BOOST_FUSION_ATTRIBUTE_GIVENTYPE)( \ NAME_SEQ, \ ATTRIBUTE, \ ATTRIBUTE_TUPLE_SIZE, \ PREFIX, \ TEMPLATE_PARAMS_SEQ) \ \ BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ \ typedef attribute_type type; \ \ template<typename Seq> \ struct apply \ { \ typedef typename \ add_reference< \ typename mpl::eval_if< \ is_const<Seq> \ , add_const<attribute_type> \ , mpl::identity<attribute_type> \ >::type \ >::type \ type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type \ call(Seq& seq) \ { \ return seq.PREFIX() \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, \ BOOST_PP_NOT(DEDUCE_TYPE), ATTRIBUTE); \ } \ }; \ }; \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ > \ struct struct_member_name< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \ , I \ > \ { \ typedef char const* type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type \ call() \ { \ return BOOST_PP_STRINGIZE( \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, \ BOOST_PP_NOT(DEDUCE_TYPE), ATTRIBUTE)); \ } \ }; #define BOOST_FUSION_ADAPT_STRUCT_BASE( \ TEMPLATE_PARAMS_SEQ, \ NAME_SEQ, \ TAG, \ IS_VIEW, \ ATTRIBUTES_SEQ, \ ATTRIBUTES_CALLBACK) \ \ namespace boost \ { \ namespace fusion \ { \ namespace traits \ { \ BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ BOOST_PP_EMPTY(), TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ BOOST_FUSION_ADAPT_STRUCT_TAG_OF_SPECIALIZATION( \ const, TEMPLATE_PARAMS_SEQ, NAME_SEQ, TAG) \ } \ \ namespace extension \ { \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ BOOST_PP_SEQ_FOR_EACH_I_R, \ BOOST_PP_TUPLE_EAT(4))( \ 1, \ BOOST_FUSION_ADAPT_STRUCT_BASE_UNPACK_AND_CALL, \ (ATTRIBUTES_CALLBACK,TEMPLATE_PARAMS_SEQ,NAME_SEQ, IS_VIEW),\ BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ)) \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ > \ struct struct_size<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)> \ : mpl::int_<BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ))> \ {}; \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ > \ struct struct_is_view< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) \ > \ : mpl::BOOST_PP_IIF(IS_VIEW,true_,false_) \ {}; \ } \ } \ \ namespace mpl \ { \ template<typename> \ struct sequence_tag; \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ > \ struct sequence_tag<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)> \ { \ typedef fusion::fusion_sequence_tag type; \ }; \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ > \ struct sequence_tag< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const \ > \ { \ typedef fusion::fusion_sequence_tag type; \ }; \ } \ } #endif struct/detail/at_impl.hpp 0000644 00000002137 15125731320 0011472 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_AT_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_AT_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/mpl/int.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct at_impl; template <> struct at_impl<struct_tag> { template <typename Seq, typename N> struct apply : access::struct_member< typename remove_const<Seq>::type , N::value >::template apply<Seq> {}; }; template <> struct at_impl<assoc_struct_tag> : at_impl<struct_tag> {}; }}} #endif struct/detail/value_at_impl.hpp 0000644 00000001770 15125731320 0012670 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_AT_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_AT_IMPL_HPP namespace boost { namespace fusion { namespace extension { template<typename> struct value_at_impl; template <> struct value_at_impl<struct_tag> { template <typename Seq, typename N> struct apply : access::struct_member<typename remove_const<Seq>::type, N::value> {}; }; template <> struct value_at_impl<assoc_struct_tag> : value_at_impl<struct_tag> {}; }}} #endif struct/detail/define_struct_inline.hpp 0000644 00000107722 15125731320 0014247 0 ustar 00 /*============================================================================= Copyright (c) 2012 Nathan Ridge 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_FUSION_ADAPTED_STRUCT_DETAIL_DEFINE_STRUCT_INLINE_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEFINE_STRUCT_INLINE_HPP #include <boost/fusion/support/config.hpp> #include <boost/config.hpp> #include <boost/fusion/support/category_of.hpp> #include <boost/fusion/sequence/sequence_facade.hpp> #include <boost/fusion/iterator/iterator_facade.hpp> #include <boost/fusion/algorithm/auxiliary/copy.hpp> #include <boost/fusion/adapted/struct/detail/define_struct.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/identity.hpp> #include <boost/mpl/minus.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/preprocessor/comma_if.hpp> #include <boost/preprocessor/facilities/empty.hpp> #include <boost/preprocessor/repeat.hpp> #include <boost/preprocessor/seq/for_each_i.hpp> #include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/seq/enum.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/tuple/elem.hpp> // MSVC and GCC <= 4.4 have a bug that affects partial specializations of // nested templates under some circumstances. This affects the implementation // of BOOST_FUSION_DEFINE_STRUCT_INLINE, which uses such specializations for // the iterator class's 'deref' and 'value_of' metafunctions. On these compilers // an alternate implementation for these metafunctions is used that does not // require such specializations. The alternate implementation takes longer // to compile so its use is restricted to the offending compilers. // For MSVC, the bug was reported at https://connect.microsoft.com/VisualStudio/feedback/details/757891/c-compiler-error-involving-partial-specializations-of-nested-templates // For GCC, 4.4 and earlier are no longer maintained so there is no need // to report a bug. #if defined(BOOST_MSVC) || (defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 4))) #define BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND #endif #ifdef BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/mpl/if.hpp> #include <boost/fusion/sequence/intrinsic/at_c.hpp> #include <boost/fusion/container/vector.hpp> #endif #define BOOST_FUSION_MAKE_DEFAULT_INIT_LIST_ENTRY(R, DATA, N, ATTRIBUTE) \ BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)() #define BOOST_FUSION_MAKE_DEFAULT_INIT_LIST(ATTRIBUTES_SEQ) \ : BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_FUSION_MAKE_DEFAULT_INIT_LIST_ENTRY, \ ~, \ ATTRIBUTES_SEQ) \ #define BOOST_FUSION_IGNORE_2(ARG1, ARG2) #define BOOST_FUSION_MAKE_COPY_CONSTRUCTOR(NAME, ATTRIBUTES_SEQ) \ BOOST_FUSION_GPU_ENABLED \ NAME(BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_FUSION_MAKE_CONST_REF_PARAM, \ ~, \ ATTRIBUTES_SEQ)) \ : BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_FUSION_MAKE_INIT_LIST_ENTRY, \ ~, \ ATTRIBUTES_SEQ) \ { \ } \ #define BOOST_FUSION_MAKE_CONST_REF_PARAM(R, DATA, N, ATTRIBUTE) \ BOOST_PP_COMMA_IF(N) \ BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) const& \ BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE) #define BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(NAME) NAME(NAME) #define BOOST_FUSION_MAKE_INIT_LIST_ENTRY(R, DATA, N, ATTRIBUTE) \ BOOST_PP_COMMA_IF(N) \ BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)) #define BOOST_FUSION_ITERATOR_NAME(NAME) \ BOOST_PP_CAT(boost_fusion_detail_, BOOST_PP_CAT(NAME, _iterator)) // Note: all template parameter names need to be uglified, otherwise they might // shadow a template parameter of the struct when used with // BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE #define BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS(Z, N, NAME) \ template <typename boost_fusion_detail_Sq> \ struct value_of< \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, N> \ > \ : boost::mpl::identity< \ typename boost_fusion_detail_Sq::t##N##_type \ > \ { \ }; #define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ SPEC_TYPE, CALL_ARG_TYPE, TYPE_QUAL, ATTRIBUTE, N) \ \ template <typename boost_fusion_detail_Sq> \ struct deref<SPEC_TYPE, N> > \ { \ typedef typename boost_fusion_detail_Sq::t##N##_type TYPE_QUAL& type; \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(CALL_ARG_TYPE, N> const& iter) \ { \ return iter.seq_.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \ } \ }; #define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS(R, NAME, N, ATTRIBUTE) \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \ , \ ATTRIBUTE, \ N) \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \ const, \ ATTRIBUTE, \ N) \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ const BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, \ , \ ATTRIBUTE, \ N) \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC( \ const BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \ BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq, \ const, \ ATTRIBUTE, \ N) \ #define BOOST_FUSION_MAKE_VALUE_AT_SPECS(Z, N, DATA) \ template <typename boost_fusion_detail_Sq> \ struct value_at<boost_fusion_detail_Sq, boost::mpl::int_<N> > \ { \ typedef typename boost_fusion_detail_Sq::t##N##_type type; \ }; #define BOOST_FUSION_MAKE_AT_SPECS(R, DATA, N, ATTRIBUTE) \ template <typename boost_fusion_detail_Sq> \ struct at<boost_fusion_detail_Sq, boost::mpl::int_<N> > \ { \ typedef typename boost::mpl::if_< \ boost::is_const<boost_fusion_detail_Sq>, \ typename boost_fusion_detail_Sq::t##N##_type const&, \ typename boost_fusion_detail_Sq::t##N##_type& \ >::type type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_Sq& sq) \ { \ return sq. BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); \ } \ }; #define BOOST_FUSION_MAKE_TYPEDEF(R, DATA, N, ATTRIBUTE) \ typedef BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) t##N##_type; #define BOOST_FUSION_MAKE_DATA_MEMBER(R, DATA, N, ATTRIBUTE) \ BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE); #ifdef BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND #define BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTE_SEQ_SIZE) \ template <typename boost_fusion_detail_Iterator> \ struct value_of : boost::fusion::result_of::at_c< \ ref_vec_t, \ boost_fusion_detail_Iterator::index::value \ > \ { \ }; #define BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ) \ template <typename boost_fusion_detail_Iterator> \ struct deref \ { \ typedef typename boost::remove_const< \ boost_fusion_detail_Iterator \ >::type iterator_raw_type; \ \ static const int index = iterator_raw_type::index::value; \ \ typedef typename boost::fusion::result_of::at_c< \ ref_vec_t, \ index \ >::type result_raw_type; \ \ typedef typename boost::mpl::if_< \ boost::is_const<typename iterator_raw_type::sequence_type>, \ typename boost::add_const<result_raw_type>::type, \ result_raw_type \ >::type type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(iterator_raw_type const& iter) \ { \ return boost::fusion::at_c<index>(iter.ref_vec); \ } \ }; #define BOOST_FUSION_MAKE_ITERATOR_WKND_FIELD_NAME(R, DATA, N, ATTRIBUTE) \ BOOST_PP_COMMA_IF(N) seq.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE) #define BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(ATTRIBUTES_SEQ) \ , ref_vec(BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_FUSION_MAKE_ITERATOR_WKND_FIELD_NAME, \ ~, \ BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ))) #define BOOST_FUSION_MAKE_ITERATOR_WKND_REF(Z, N, DATA) \ BOOST_PP_COMMA_IF(N) \ typename boost::mpl::if_< \ boost::is_const<boost_fusion_detail_Seq>, \ typename boost::add_const< \ typename boost_fusion_detail_Seq::t##N##_type \ >::type, \ typename boost_fusion_detail_Seq::t##N##_type \ >::type& #define BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE) \ typedef boost::fusion::vector< \ BOOST_PP_REPEAT( \ ATTRIBUTES_SEQ_SIZE, \ BOOST_FUSION_MAKE_ITERATOR_WKND_REF, \ ~) \ > ref_vec_t; \ \ ref_vec_t ref_vec; #else #define BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTES_SEQ_SIZE) \ template <typename boost_fusion_detail_T> struct value_of; \ BOOST_PP_REPEAT( \ ATTRIBUTES_SEQ_SIZE, \ BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS, \ NAME) #define BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ) \ template <typename boost_fusion_detail_T> struct deref; \ BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS, \ NAME, \ ATTRIBUTES_SEQ) #define BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(ATTRIBUTES_SEQ) #define BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE) #endif // BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND // Note: We can't nest the iterator inside the struct because we run into // a MSVC10 bug involving partial specializations of nested templates. #define BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES) \ BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \ struct NAME : boost::fusion::sequence_facade< \ NAME, \ boost::fusion::random_access_traversal_tag \ > \ { \ BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES) \ }; #define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \ \ template < \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL( \ (0)TEMPLATE_PARAMS_SEQ) \ > \ struct NAME : boost::fusion::sequence_facade< \ NAME< \ BOOST_PP_SEQ_ENUM(TEMPLATE_PARAMS_SEQ) \ >, \ boost::fusion::random_access_traversal_tag \ > \ { \ BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES) \ }; #define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES) \ BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL( \ NAME, \ BOOST_PP_CAT(BOOST_FUSION_DEFINE_STRUCT_FILLER_0 ATTRIBUTES,_END)) // Note: can't compute BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ) directly because // ATTRIBUTES_SEQ may be empty and calling BOOST_PP_SEQ_SIZE on an empty // sequence produces warnings on MSVC. #define BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL(NAME, ATTRIBUTES_SEQ) \ BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \ NAME, \ ATTRIBUTES_SEQ, \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ))) #define BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES) \ BOOST_FUSION_DEFINE_STRUCT_ITERATOR_IMPL( \ NAME, \ BOOST_PP_CAT(BOOST_FUSION_DEFINE_STRUCT_FILLER_0 ATTRIBUTES,_END)) #define BOOST_FUSION_DEFINE_STRUCT_ITERATOR_IMPL(NAME, ATTRIBUTES_SEQ) \ BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR_IMPL_IMPL( \ NAME, \ ATTRIBUTES_SEQ, \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ))) #define BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR_IMPL_IMPL( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE) \ \ template <typename boost_fusion_detail_Seq, int N> \ struct BOOST_FUSION_ITERATOR_NAME(NAME) \ : boost::fusion::iterator_facade< \ BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Seq, N>, \ boost::fusion::random_access_traversal_tag \ > \ { \ typedef boost::mpl::int_<N> index; \ typedef boost_fusion_detail_Seq sequence_type; \ \ BOOST_FUSION_GPU_ENABLED \ BOOST_FUSION_ITERATOR_NAME(NAME)(boost_fusion_detail_Seq& seq) \ : seq_(seq) \ BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES( \ (0)ATTRIBUTES_SEQ) \ {} \ \ boost_fusion_detail_Seq& seq_; \ \ BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE) \ \ BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTES_SEQ_SIZE) \ \ BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ) \ \ template <typename boost_fusion_detail_It> \ struct next \ { \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \ typename boost_fusion_detail_It::sequence_type, \ boost_fusion_detail_It::index::value + 1 \ > type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_It const& it) \ { \ return type(it.seq_); \ } \ }; \ \ template <typename boost_fusion_detail_It> \ struct prior \ { \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \ typename boost_fusion_detail_It::sequence_type, \ boost_fusion_detail_It::index::value - 1 \ > type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_It const& it) \ { \ return type(it.seq_); \ } \ }; \ \ template < \ typename boost_fusion_detail_It1, \ typename boost_fusion_detail_It2 \ > \ struct distance \ { \ typedef typename boost::mpl::minus< \ typename boost_fusion_detail_It2::index, \ typename boost_fusion_detail_It1::index \ >::type type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_It1 const& /* it1 */, \ boost_fusion_detail_It2 const& /* it2 */) \ { \ return type(); \ } \ }; \ \ template < \ typename boost_fusion_detail_It, \ typename boost_fusion_detail_M \ > \ struct advance \ { \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \ typename boost_fusion_detail_It::sequence_type, \ boost_fusion_detail_It::index::value \ + boost_fusion_detail_M::value \ > type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_It const& it) \ { \ return type(it.seq_); \ } \ }; \ }; #define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE) \ \ NAME() \ BOOST_PP_IF(ATTRIBUTES_SEQ_SIZE, \ BOOST_FUSION_MAKE_DEFAULT_INIT_LIST, \ BOOST_PP_EMPTY)(ATTRIBUTES_SEQ) \ { \ } \ \ BOOST_PP_IF( \ ATTRIBUTES_SEQ_SIZE, \ BOOST_FUSION_MAKE_COPY_CONSTRUCTOR, \ BOOST_FUSION_IGNORE_2) \ (NAME, ATTRIBUTES_SEQ) \ \ template <typename boost_fusion_detail_Seq> \ BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ NAME(const boost_fusion_detail_Seq& rhs) \ { \ boost::fusion::copy(rhs, *this); \ } \ \ template <typename boost_fusion_detail_Seq> \ BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ NAME& operator=(const boost_fusion_detail_Seq& rhs) \ { \ boost::fusion::copy(rhs, *this); \ return *this; \ } \ \ template <typename boost_fusion_detail_Sq> \ struct begin \ { \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, 0> \ type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_Sq& sq) \ { \ return type(sq); \ } \ }; \ \ template <typename boost_fusion_detail_Sq> \ struct end \ { \ typedef BOOST_FUSION_ITERATOR_NAME(NAME)< \ boost_fusion_detail_Sq, \ ATTRIBUTES_SEQ_SIZE \ > type; \ \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ static type call(boost_fusion_detail_Sq& sq) \ { \ return type(sq); \ } \ }; \ \ template <typename boost_fusion_detail_Sq> \ struct size : boost::mpl::int_<ATTRIBUTES_SEQ_SIZE> \ { \ }; \ \ template <typename boost_fusion_detail_Sq> \ struct empty : boost::mpl::bool_<ATTRIBUTES_SEQ_SIZE == 0> \ { \ }; \ \ template < \ typename boost_fusion_detail_Sq, \ typename boost_fusion_detail_N \ > \ struct value_at : value_at< \ boost_fusion_detail_Sq, \ boost::mpl::int_<boost_fusion_detail_N::value> \ > \ { \ }; \ \ BOOST_PP_REPEAT( \ ATTRIBUTES_SEQ_SIZE, \ BOOST_FUSION_MAKE_VALUE_AT_SPECS, \ ~) \ \ template < \ typename boost_fusion_detail_Sq, \ typename boost_fusion_detail_N \ > \ struct at : at< \ boost_fusion_detail_Sq, \ boost::mpl::int_<boost_fusion_detail_N::value> \ > \ { \ }; \ \ BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_MAKE_AT_SPECS, ~, ATTRIBUTES_SEQ) \ \ BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_MAKE_TYPEDEF, ~, ATTRIBUTES_SEQ) \ \ BOOST_PP_SEQ_FOR_EACH_I( \ BOOST_FUSION_MAKE_DATA_MEMBER, \ ~, \ ATTRIBUTES_SEQ) #endif struct/detail/deref_impl.hpp 0000644 00000002275 15125731320 0012156 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEREF_IMPL_HPP namespace boost { namespace fusion { namespace extension { template <typename> struct deref_impl; template <> struct deref_impl<struct_iterator_tag> { template <typename It> struct apply { typedef typename access::struct_member< typename remove_const<typename It::seq_type>::type , It::index::value >::template apply<typename It::seq_type> impl; typedef typename impl::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(It const& it) { return impl::call(*it.seq); } }; }; }}} #endif struct/detail/define_struct.hpp 0000644 00000075214 15125731320 0012711 0 ustar 00 /*============================================================================= Copyright (c) 2010-2011 Christopher Schmidt 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_FUSION_ADAPTED_DETAIL_STRUCT_DEFINE_STRUCT_HPP #define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_DEFINE_STRUCT_HPP #include <boost/fusion/support/config.hpp> #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/iterator/deref.hpp> #include <boost/fusion/iterator/next.hpp> #include <boost/fusion/iterator/advance.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base.hpp> #include <boost/fusion/adapted/struct/detail/namespace.hpp> #include <boost/preprocessor/if.hpp> #include <boost/preprocessor/expr_if.hpp> #include <boost/preprocessor/dec.hpp> #include <boost/preprocessor/logical/not.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/seq/for_each_i.hpp> #include <boost/preprocessor/seq/enum.hpp> #include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/tuple/eat.hpp> #include <boost/call_traits.hpp> #include <boost/type_traits/is_convertible.hpp> #include <boost/utility/enable_if.hpp> #define BOOST_FUSION_DEFINE_STRUCT_FILLER_0(X, Y) \ ((X, Y)) BOOST_FUSION_DEFINE_STRUCT_FILLER_1 #define BOOST_FUSION_DEFINE_STRUCT_FILLER_1(X, Y) \ ((X, Y)) BOOST_FUSION_DEFINE_STRUCT_FILLER_0 #define BOOST_FUSION_DEFINE_STRUCT_FILLER_0_END #define BOOST_FUSION_DEFINE_STRUCT_FILLER_1_END #ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #define BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)( \ other_self.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)) #define BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ NAME(self_type const& other_self) \ : BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ {} // Use templated version instead. #define BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I_, ATTRIBUTE) \ \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)= \ other.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE); #define BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ self_type& operator=(self_type const& other) \ { \ BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ \ return *this; \ } #else // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #define BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED NAME(self_type const&) = default; #define BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED self_type& operator=(self_type const&) = default; #endif // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #define BOOST_FUSION_DEFINE_STRUCT_ASSIGN_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I_, ATTRIBUTE) \ \ BOOST_PP_EXPR_IF( \ I_, \ typedef typename \ boost::fusion::result_of::next< \ BOOST_PP_CAT(I,BOOST_PP_DEC(I_)) \ >::type \ BOOST_PP_CAT(I,I_); \ BOOST_PP_CAT(I,I_) BOOST_PP_CAT(i,I_)= \ boost::fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(I_))); \ ) \ \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)= \ boost::fusion::deref(BOOST_PP_CAT(i,I_)); #define BOOST_FUSION_DEFINE_STRUCT_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ template<typename Seq> \ BOOST_FUSION_GPU_ENABLED \ self_type& \ operator=(Seq const& seq) \ { \ typedef typename \ boost::fusion::result_of::begin<Seq const>::type \ I0; \ I0 i0=boost::fusion::begin(seq); \ \ BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_ASSIGN_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ \ return *this; \ } #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR(NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP(ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #else // BOOST_NO_CXX11_RVALUE_REFERENCES #if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) \ || BOOST_WORKAROUND(BOOST_GCC, < 40500) \ || BOOST_WORKAROUND(BOOST_MSVC, == 1800) #define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)(std::move( \ other_self.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE))) #define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ NAME(self_type&& other_self) \ : BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ {} #else // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #define BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED NAME(self_type&&) = default; #endif // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) \ || BOOST_WORKAROUND(BOOST_GCC, < 40600) \ || BOOST_WORKAROUND(BOOST_MSVC, == 1800) #define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I_, ATTRIBUTE) \ \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)=std::move( \ other.BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)); #define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ self_type& operator=(self_type&& other) \ { \ BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ \ return *this; \ } #else // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #define BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED self_type& operator=(self_type&&) = default; #endif // BOOST_NO_CXX11_DEFAULTED_FUNCTIONS #endif // BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_FUSION_DEFINE_STRUCT_ATTR_I(R, ATTRIBUTE_TUPLE_SIZE, ATTRIBUTE) \ \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,0,ATTRIBUTE) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE); #define BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)( \ boost::fusion::deref(boost::fusion::advance_c<I>(boost::fusion::begin( \ seq)))) #define BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_DISABLER( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ , typename boost::disable_if< \ boost::is_convertible< \ Seq const& \ , BOOST_PP_TUPLE_ELEM( \ ATTRIBUTE_TUPLE_SIZE, \ 0, \ BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ)) \ > \ >::type* =0 #define BOOST_FUSION_DEFINE_STRUCT_SEQ_DEFAULT_CTOR_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)() #define BOOST_FUSION_DEFINE_STRUCT_IMPL_IMPL( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_PP_SEQ_FOR_EACH_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_ATTR_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ \ BOOST_FUSION_GPU_ENABLED \ NAME() \ : BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_SEQ_DEFAULT_CTOR_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ {} \ \ BOOST_FUSION_DEFINE_STRUCT_COPY_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ BOOST_FUSION_DEFINE_STRUCT_MOVE_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ template<typename Seq> \ BOOST_FUSION_GPU_ENABLED \ NAME(Seq const& seq \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ BOOST_PP_TUPLE_EAT(2), \ BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_DISABLER)( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ ) \ : BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_SEQ_CTOR_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ {} \ \ BOOST_FUSION_DEFINE_STRUCT_COPY_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ BOOST_FUSION_DEFINE_STRUCT_MOVE_ASSIGN_OP( \ ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ BOOST_FUSION_DEFINE_STRUCT_ASSIGN_OP(ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_STRUCT_CTOR_1( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ explicit \ NAME(boost::call_traits< \ BOOST_PP_TUPLE_ELEM( \ ATTRIBUTE_TUPLE_SIZE,0,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ)) \ >::param_type arg) \ : BOOST_PP_TUPLE_ELEM( \ ATTRIBUTE_TUPLE_SIZE,1,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))(arg) \ {} #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_1( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ explicit \ NAME(typename boost::call_traits< \ typename boost::fusion::detail::get_first_arg< \ BOOST_PP_TUPLE_ELEM( \ ATTRIBUTE_TUPLE_SIZE, \ 0, \ BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ)) \ , BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ) \ >::type \ >::param_type arg) \ : BOOST_PP_TUPLE_ELEM( \ ATTRIBUTE_TUPLE_SIZE,1,BOOST_PP_SEQ_HEAD(ATTRIBUTES_SEQ))(arg) \ {} #define BOOST_FUSION_DEFINE_STRUCT_CTOR_FILLER_I( \ R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,1,ATTRIBUTE)(BOOST_PP_CAT(_,I)) #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_ARG_I(R, DATA, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ typename boost::call_traits< \ typename boost::fusion::detail::get_first_arg< \ BOOST_PP_TUPLE_ELEM( \ BOOST_PP_TUPLE_ELEM(3,0,DATA), \ 0, \ ATTRIBUTE) \ , BOOST_PP_TUPLE_ELEM(3,2,DATA) \ >::type \ >::param_type BOOST_PP_CAT(_,I) #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_N( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ NAME(BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_ARG_I, \ ( \ ATTRIBUTE_TUPLE_SIZE, \ BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ), \ BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ) \ ), \ ATTRIBUTES_SEQ)) \ : BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_CTOR_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ {} #define BOOST_FUSION_DEFINE_STRUCT_CTOR_ARG_I( \ R, ATTRIBUTE_TUPLE_SIZE, I, ATTRIBUTE) \ \ BOOST_PP_COMMA_IF(I) \ boost::call_traits< \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,0,ATTRIBUTE) \ >::param_type BOOST_PP_CAT(_,I) #define BOOST_FUSION_DEFINE_STRUCT_CTOR_N( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_GPU_ENABLED \ NAME(BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_CTOR_ARG_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ)) \ : BOOST_PP_SEQ_FOR_EACH_I_R( \ 1, \ BOOST_FUSION_DEFINE_STRUCT_CTOR_FILLER_I, \ ATTRIBUTE_TUPLE_SIZE, \ ATTRIBUTES_SEQ) \ {} #define BOOST_FUSION_DEFINE_STRUCT_CTOR( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ BOOST_FUSION_DEFINE_STRUCT_CTOR_N, \ BOOST_FUSION_DEFINE_STRUCT_CTOR_1)( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_N, \ BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR_1)( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_NONEMPTY_STRUCT_IMPL( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_DEFINE_STRUCT_IMPL_IMPL( \ NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_DEFINE_STRUCT_CTOR( \ NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_EMPTY_STRUCT_IMPL( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_STRUCT_IMPL( \ NAMESPACE_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_BEGIN(NAMESPACE_SEQ) \ \ struct NAME \ { \ typedef NAME self_type; \ \ BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ BOOST_FUSION_DEFINE_NONEMPTY_STRUCT_IMPL, \ BOOST_FUSION_DEFINE_EMPTY_STRUCT_IMPL)( \ NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ }; \ \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ) #define BOOST_FUSION_DEFINE_NONEMPTY_TPL_STRUCT_IMPL( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_DEFINE_STRUCT_IMPL_IMPL( \ NAME, BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_DEFINE_TPL_STRUCT_CTOR( \ TEMPLATE_PARAMS_SEQ, \ NAME, \ BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ), \ ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_EMPTY_TPL_STRUCT_IMPL( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE) #define BOOST_FUSION_DEFINE_TPL_STRUCT_IMPL( \ TEMPLATE_PARAMS_SEQ, \ NAMESPACE_SEQ, \ NAME, \ ATTRIBUTES_SEQ, \ ATTRIBUTE_TUPLE_SIZE) \ \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_BEGIN(NAMESPACE_SEQ) \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL( \ (0)TEMPLATE_PARAMS_SEQ) \ > \ struct NAME \ { \ typedef NAME self_type; \ \ BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ)), \ BOOST_FUSION_DEFINE_NONEMPTY_TPL_STRUCT_IMPL, \ BOOST_FUSION_DEFINE_EMPTY_TPL_STRUCT_IMPL)( \ TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES_SEQ, ATTRIBUTE_TUPLE_SIZE)\ }; \ \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ) namespace boost { namespace fusion { namespace detail { template<typename A1, typename A2> struct get_first_arg { typedef A1 type; }; }}} #endif struct/detail/namespace.hpp 0000644 00000005464 15125731320 0012007 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Hartmut Kaiser Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_DETAIL_STRUCT_NAMESPACE_HPP #define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_NAMESPACE_HPP #include <boost/fusion/support/config.hpp> #include <boost/preprocessor/dec.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/tuple/eat.hpp> #define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_BEGIN_I(R,DATA,ELEM) \ namespace ELEM { #define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_END_I(Z,I,DATA) } #define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION_I(Z,I,ELEM) ELEM:: #define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_BEGIN(NAMESPACE_SEQ) \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(NAMESPACE_SEQ)), \ BOOST_PP_SEQ_FOR_EACH_R, \ BOOST_PP_TUPLE_EAT(4))( \ 1, \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_BEGIN_I, \ _, \ BOOST_PP_SEQ_TAIL(NAMESPACE_SEQ)) #define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ) \ BOOST_PP_REPEAT_1( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(NAMESPACE_SEQ)), \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_END_I, \ _) #define BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION(NAMESPACE_SEQ) \ BOOST_PP_IF( \ BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(NAMESPACE_SEQ)), \ BOOST_PP_SEQ_FOR_EACH_R, \ BOOST_PP_TUPLE_EAT(4))( \ 1, \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION_I, \ _, \ BOOST_PP_SEQ_TAIL(NAMESPACE_SEQ)) #endif struct/detail/begin_impl.hpp 0000644 00000003455 15125731320 0012156 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_BEGIN_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_BEGIN_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/iterator/basic_iterator.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct begin_impl; template <> struct begin_impl<struct_tag> { template <typename Seq> struct apply { typedef basic_iterator< struct_iterator_tag , random_access_traversal_tag , Seq , 0 > type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return type(seq,0); } }; }; template <> struct begin_impl<assoc_struct_tag> { template <typename Seq> struct apply { typedef basic_iterator< struct_iterator_tag , assoc_struct_category , Seq , 0 > type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Seq& seq) { return type(seq,0); } }; }; }}} #endif struct/detail/size_impl.hpp 0000644 00000001700 15125731320 0012033 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_SIZE_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_SIZE_IMPL_HPP namespace boost { namespace fusion { namespace extension { template<typename> struct size_impl; template <> struct size_impl<struct_tag> { template <typename Seq> struct apply : struct_size<typename remove_const<Seq>::type> {}; }; template <> struct size_impl<assoc_struct_tag> : size_impl<struct_tag> {}; }}} #endif struct/detail/adapt_auto.hpp 0000644 00000001064 15125731320 0012164 0 ustar 00 /*============================================================================= Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_AUTO_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_AUTO_HPP #define BOOST_FUSION_ADAPT_AUTO auto #define BOOST_MPL_PP_TOKEN_EQUAL_auto(x) x #endif struct/detail/value_of_impl.hpp 0000644 00000001603 15125731320 0012663 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_IMPL_HPP namespace boost { namespace fusion { namespace extension { template <typename> struct value_of_impl; template <> struct value_of_impl<struct_iterator_tag> { template <typename It> struct apply : access::struct_member< typename remove_const<typename It::seq_type>::type , It::index::value > {}; }; }}} #endif struct/detail/extension.hpp 0000644 00000003007 15125731320 0012056 0 ustar 00 /*============================================================================= Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_EXTENSION_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_EXTENSION_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/category_of.hpp> namespace boost { namespace fusion { struct struct_tag; struct struct_iterator_tag; struct assoc_struct_tag; struct fusion_sequence_tag; struct assoc_struct_category : random_access_traversal_tag, associative_tag {}; namespace extension { struct no_such_member; struct access { template<typename Seq, int N> struct struct_member; template<typename Seq, int N> struct adt_attribute_access; }; template <typename T, int N, bool Const> struct adt_attribute_proxy; template<typename Seq, int N> struct struct_member_name; template<typename Seq> struct struct_size; template<typename Seq> struct struct_is_view; template<typename Seq, int N> struct struct_assoc_key; } }} #endif struct/detail/value_of_data_impl.hpp 0000644 00000001350 15125731320 0013653 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_DATA_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_OF_DATA_IMPL_HPP namespace boost { namespace fusion { namespace extension { template <typename> struct value_of_data_impl; template <> struct value_of_data_impl<struct_iterator_tag> : value_of_impl<struct_iterator_tag> {}; }}} #endif struct/detail/adapt_base_attr_filler.hpp 0000644 00000006067 15125731320 0014525 0 ustar 00 /*============================================================================= Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ATTR_FILLER_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ATTR_FILLER_HPP #include <boost/config.hpp> #include <boost/fusion/adapted/struct/detail/adapt_auto.hpp> #include <boost/fusion/adapted/struct/detail/preprocessor/is_seq.hpp> #include <boost/mpl/aux_/preprocessor/token_equal.hpp> #include <boost/preprocessor/config/config.hpp> #include <boost/preprocessor/control/iif.hpp> #include <boost/preprocessor/control/expr_iif.hpp> #include <boost/preprocessor/logical/compl.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/seq/push_front.hpp> #include <boost/preprocessor/facilities/expand.hpp> #include <boost/preprocessor/facilities/is_empty.hpp> #define BOOST_FUSION_ADAPT_STRUCT_FILLER_0(X, Y) \ BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X,Y) \ BOOST_FUSION_ADAPT_STRUCT_FILLER_1 #define BOOST_FUSION_ADAPT_STRUCT_FILLER_1(X, Y) \ BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X,Y) \ BOOST_FUSION_ADAPT_STRUCT_FILLER_0 #define BOOST_FUSION_ADAPT_STRUCT_FILLER_0_END #define BOOST_FUSION_ADAPT_STRUCT_FILLER_1_END #define BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X, Y) \ BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, BOOST_PP_EXPAND(X)), \ ((1, (Y))), \ ((2, (X,Y))) \ ) #define BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE) \ BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) #define BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE) \ BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE) #if BOOST_PP_VARIADICS # define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER_OP(r, unused, elem) \ BOOST_PP_IIF(BOOST_FUSION_PP_IS_SEQ(elem), \ BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 elem ,_END), \ BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_EMPTY(elem)), \ BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(auto, elem))) # define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(VA_ARGS_SEQ) \ BOOST_PP_SEQ_PUSH_FRONT( \ BOOST_PP_SEQ_FOR_EACH( \ BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER_OP, \ unused, VA_ARGS_SEQ), \ (0,0)) #endif // BOOST_PP_VARIADICS #endif struct/detail/adapt_is_tpl.hpp 0000644 00000001217 15125731320 0012506 0 ustar 00 /*============================================================================= Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_IS_TPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_IS_TPL_HPP #include <boost/preprocessor/seq/seq.hpp> #define BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ) \ BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ) #endif struct/detail/adapt_base_assoc_attr_filler.hpp 0000644 00000006503 15125731320 0015710 0 ustar 00 /*============================================================================= Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ASSOC_ATTR_FILLER_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ASSOC_ATTR_FILLER_HPP #include <boost/config.hpp> #include <boost/fusion/adapted/struct/detail/adapt_auto.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base_attr_filler.hpp> #include <boost/mpl/aux_/preprocessor/token_equal.hpp> #include <boost/preprocessor/config/config.hpp> #include <boost/preprocessor/control/iif.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/variadic/size.hpp> #include <boost/preprocessor/variadic/elem.hpp> #if BOOST_PP_VARIADICS #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(...) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(__VA_ARGS__) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1(...) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(__VA_ARGS__) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(...) \ BOOST_PP_IIF( \ BOOST_MPL_PP_TOKEN_EQUAL(auto, BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__)), \ ((2, \ (BOOST_PP_VARIADIC_ELEM(1, __VA_ARGS__), \ BOOST_PP_VARIADIC_ELEM(2, __VA_ARGS__)))), \ ((BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), \ (__VA_ARGS__))) \ ) #else // BOOST_PP_VARIADICS #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(X, Y, Z) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(X, Y, Z) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1(X, Y, Z) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(X, Y, Z) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0 #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAP_ATTR(X, Y, Z) \ BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, X), \ ((2, (Y,Z))), \ ((3, (X,Y,Z))) \ ) #endif // BOOST_PP_VARIADICS #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0_END #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_1_END #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAPPEDATTR_GET_KEY(ATTRIBUTE) \ BOOST_PP_TUPLE_ELEM( \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), \ BOOST_PP_DEC(BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE)), \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE)) #endif struct/detail/preprocessor/is_seq.hpp 0000644 00000002623 15125731320 0014056 0 ustar 00 /*============================================================================= BOOST_PP_VARIADICS version of BOOST_PP_IS_SEQ inspired from boost/mpl/aux_/preprocessor/is_seq.hpp, original copyrights goes to : Copyright Paul Mensonides 2003 Copyright Aleksey Gurtovoy 2003-2004 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_FUSION_ADAPTED_STRUCT_DETAIL_PREPROCESSOR_IS_SEQ_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_PREPROCESSOR_IS_SEQ_HPP #include <boost/preprocessor/punctuation/paren.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/config/config.hpp> #if BOOST_PP_VARIADICS #define BOOST_FUSION_PP_IS_SEQ(seq) BOOST_PP_CAT(BOOST_FUSION_PP_IS_SEQ_, \ BOOST_FUSION_PP_IS_SEQ_0 seq BOOST_PP_RPAREN()) #define BOOST_FUSION_PP_IS_SEQ_0(...) \ BOOST_FUSION_PP_IS_SEQ_1(__VA_ARGS__ #define BOOST_FUSION_PP_IS_SEQ_ALWAYS_0(...) \ 0 #define BOOST_FUSION_PP_IS_SEQ_BOOST_FUSION_PP_IS_SEQ_0 \ BOOST_FUSION_PP_IS_SEQ_ALWAYS_0( #define BOOST_FUSION_PP_IS_SEQ_BOOST_FUSION_PP_IS_SEQ_1(...) \ 1 #endif // BOOST_PP_VARIADICS #endif struct/detail/is_sequence_impl.hpp 0000644 00000002017 15125731320 0013366 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_IS_SEQUENCE_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_SEQUENCE_IMPL_HPP #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { namespace extension { template<typename> struct is_sequence_impl; template<> struct is_sequence_impl<struct_tag> { template<typename Seq> struct apply : mpl::true_ {}; }; template <> struct is_sequence_impl<assoc_struct_tag> : is_sequence_impl<struct_tag> {}; }}} #endif struct/detail/is_view_impl.hpp 0000644 00000001723 15125731320 0012533 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_IS_VIEW_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_IS_VIEW_IMPL_HPP namespace boost { namespace fusion { namespace extension { template<typename> struct is_view_impl; template<> struct is_view_impl<struct_tag> { template<typename Seq> struct apply : struct_is_view<typename remove_const<Seq>::type> {}; }; template <> struct is_view_impl<assoc_struct_tag> : is_view_impl<struct_tag> {}; }}} #endif struct/detail/proxy_type.hpp 0000644 00000004722 15125731320 0012271 0 ustar 00 /*============================================================================= Copyright (c) 2009-2010 Hartmut Kaiser Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_DETAIL_STRUCT_PROXY_TYPE_HPP #define BOOST_FUSION_ADAPTED_DETAIL_STRUCT_PROXY_TYPE_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/detail/namespace.hpp> #define BOOST_FUSION_PROXY_PREFIX() obj. #define BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE_IMPL( \ WRAPPED_TYPE,NAMESPACE_SEQ,NAME) \ \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_BEGIN(NAMESPACE_SEQ) \ \ struct NAME \ { \ BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED \ NAME(WRAPPED_TYPE& in_obj) \ : obj(in_obj) \ {} \ \ WRAPPED_TYPE& obj; \ \ BOOST_DELETED_FUNCTION(NAME& operator= (NAME const&)) \ }; \ \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DEFINITION_END(NAMESPACE_SEQ) #define BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE( \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME) \ \ BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE_IMPL( \ WRAPPED_TYPE, (0)NAMESPACE_SEQ, NAME) #endif struct/detail/category_of_impl.hpp 0000644 00000002242 15125731320 0013364 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_DETAIL_CATEGORY_OF_IMPL_HPP #define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_CATEGORY_OF_IMPL_HPP namespace boost { namespace fusion { namespace extension { template<typename> struct category_of_impl; template<> struct category_of_impl<struct_tag> { template<typename Seq> struct apply { typedef random_access_traversal_tag type; }; }; template<> struct category_of_impl<assoc_struct_tag> { template<typename Seq> struct apply { typedef assoc_struct_category type; }; }; } }} #endif struct/adapt_assoc_struct.hpp 0000644 00000014077 15125731320 0012476 0 ustar 00 /*============================================================================= Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2007 Dan Marsden Copyright (c) 2009-2011 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_HPP #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_HPP #include <boost/fusion/support/config.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/empty.hpp> #include <boost/preprocessor/control/iif.hpp> #include <boost/preprocessor/comparison/less.hpp> #include <boost/fusion/adapted/struct/detail/extension.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base_assoc_attr_filler.hpp> #include <boost/fusion/adapted/struct/detail/at_impl.hpp> #include <boost/fusion/adapted/struct/detail/is_view_impl.hpp> #include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_at_impl.hpp> #include <boost/fusion/adapted/struct/detail/category_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/size_impl.hpp> #include <boost/fusion/adapted/struct/detail/begin_impl.hpp> #include <boost/fusion/adapted/struct/detail/end_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_data_impl.hpp> #include <boost/fusion/adapted/struct/detail/key_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_of_data_impl.hpp> #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE( \ TEMPLATE_PARAMS_SEQ,NAME_SEQ,IS_VIEW,I,PREFIX,ATTRIBUTE) \ \ BOOST_FUSION_ADAPT_STRUCT_C_BASE( \ TEMPLATE_PARAMS_SEQ, \ NAME_SEQ, \ IS_VIEW, \ I, \ BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY), \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE), \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE), \ BOOST_PP_LESS( \ BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE),3)) \ \ template< \ BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ) \ > \ struct struct_assoc_key<BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ), I> \ { \ typedef \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_WRAPPEDATTR_GET_KEY(ATTRIBUTE) type; \ }; #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_C( \ TEMPLATE_PARAMS_SEQ,NAME_SEQ,IS_VIEW, I, ATTRIBUTE) \ \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_C_BASE( \ TEMPLATE_PARAMS_SEQ,NAME_SEQ,IS_VIEW,I,BOOST_PP_EMPTY,ATTRIBUTE) #define BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT( \ TEMPLATE_PARAMS_SEQ, NAME_SEQ, ATTRIBUTES) \ \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (1)TEMPLATE_PARAMS_SEQ, \ (1)NAME_SEQ, \ assoc_struct_tag, \ 0, \ BOOST_PP_CAT( \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(0,0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_C) #define BOOST_FUSION_ADAPT_ASSOC_STRUCT(NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(NAME), \ assoc_struct_tag, \ 0, \ BOOST_PP_CAT( \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(0,0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_C) #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_AS_VIEW(NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(NAME), \ assoc_struct_tag, \ 1, \ BOOST_PP_CAT( \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_FILLER_0(0,0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_C) #endif struct/adapt_assoc_struct_named.hpp 0000644 00000003050 15125731320 0013627 0 ustar 00 /*============================================================================= Copyright (c) 2010-2011 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_NAMED_HPP #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_ASSOC_STRUCT_NAMED_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp> #include <boost/fusion/adapted/struct/detail/proxy_type.hpp> #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS( \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE_IMPL( \ WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME) \ \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_AS_VIEW( \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ)NAME, \ ATTRIBUTES) #define BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS( \ WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES) #endif struct/adapt_struct_named.hpp 0000644 00000005434 15125731320 0012447 0 ustar 00 /*============================================================================= Copyright (c) 2001-2007 Joel de Guzman Copyright (c) 2009-2010 Hartmut Kaiser Copyright (c) 2010-2011 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_NAMED_HPP #define BOOST_FUSION_ADAPTED_STRUCT_ADAPT_STRUCT_NAMED_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_struct.hpp> #include <boost/fusion/adapted/struct/detail/proxy_type.hpp> #include <boost/preprocessor/config/config.hpp> #ifdef BOOST_PP_VARIADICS # define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS( \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ...) \ \ BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE_IMPL( \ WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME) \ \ BOOST_FUSION_ADAPT_STRUCT_AS_VIEW( \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION( \ (0)NAMESPACE_SEQ)NAME, \ __VA_ARGS__) # define BOOST_FUSION_ADAPT_STRUCT_NAMED(WRAPPED_TYPE, NAME, ...) \ BOOST_FUSION_ADAPT_STRUCT_NAMED_NS( \ WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,__VA_ARGS__) #else // BOOST_PP_VARIADICS # define BOOST_FUSION_ADAPT_STRUCT_NAMED_NS( \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE_IMPL( \ WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME) \ \ BOOST_FUSION_ADAPT_STRUCT_AS_VIEW( \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION( \ (0)NAMESPACE_SEQ)NAME, \ ATTRIBUTES) # define BOOST_FUSION_ADAPT_STRUCT_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_NAMED_NS( \ WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES) #endif #endif struct.hpp 0000644 00000001765 15125731320 0006611 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STRUCT_HPP #define BOOST_FUSION_ADAPTED_STRUCT_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp> #include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp> #include <boost/fusion/adapted/struct/adapt_struct_named.hpp> #include <boost/fusion/adapted/struct/adapt_struct.hpp> #include <boost/fusion/adapted/struct/define_assoc_struct.hpp> #include <boost/fusion/adapted/struct/define_struct.hpp> #include <boost/fusion/adapted/struct/define_struct_inline.hpp> #endif std_tuple/mpl/clear.hpp 0000644 00000001324 15125731320 0011135 0 ustar 00 /*============================================================================= Copyright (c) 2012 Kohei Takahashi 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CLEAR_10172012_0940) #define BOOST_FUSION_CLEAR_10172012_0940 #include <boost/mpl/identity.hpp> #include <boost/fusion/adapted/std_tuple/tag_of.hpp> namespace boost { namespace fusion { namespace detail { template <typename Tag> struct clear; template <> struct clear<std_tuple_tag> : mpl::identity<std::tuple<> > {}; }}} #endif std_tuple/std_tuple_iterator.hpp 0000644 00000007125 15125731320 0013200 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(FUSION_STD_TUPLE_ITERATOR_09112011_1905) #define FUSION_STD_TUPLE_ITERATOR_09112011_1905 #include <boost/fusion/support/config.hpp> #include <boost/fusion/iterator/iterator_facade.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/fusion/support/detail/access.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/if.hpp> #include <tuple> #include <utility> namespace boost { namespace fusion { struct random_access_traversal_tag; template <typename Tuple, int Index> struct std_tuple_iterator_identity; template <typename Tuple, int Index> struct std_tuple_iterator : iterator_facade< std_tuple_iterator<Tuple, Index> , random_access_traversal_tag> { typedef Tuple tuple_type; static int const index = Index; typedef std_tuple_iterator_identity< typename add_const<Tuple>::type, Index> identity; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED explicit std_tuple_iterator(Tuple& tuple) : tuple(tuple) {} Tuple& tuple; template <typename Iterator> struct value_of : std::tuple_element<Iterator::index, typename remove_const<typename Iterator::tuple_type>::type> {}; template <typename Iterator> struct deref { typedef typename value_of<Iterator>::type element; typedef typename mpl::if_< is_const<typename Iterator::tuple_type> , typename fusion::detail::cref_result<element>::type , typename fusion::detail::ref_result<element>::type >::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator const& iter) { return std::get<Index>(iter.tuple); } }; template <typename Iterator, typename N> struct advance { static int const index = Iterator::index; typedef typename Iterator::tuple_type tuple_type; typedef std_tuple_iterator<tuple_type, index+N::value> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator const& i) { return type(i.tuple); } }; template <typename Iterator> struct next : advance<Iterator, mpl::int_<1>> {}; template <typename Iterator> struct prior : advance<Iterator, mpl::int_<-1>> {}; template <typename I1, typename I2> struct equal_to : is_same<typename I1::identity, typename I2::identity> {}; template <typename First, typename Last> struct distance { typedef mpl::int_<Last::index-First::index> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(First const&, Last const&) { return type(); } }; }; }} #ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408 namespace std { template <typename Tuple, int Index> struct iterator_traits< ::boost::fusion::std_tuple_iterator<Tuple, Index> > { }; } #endif #endif std_tuple/tag_of.hpp 0000644 00000002326 15125731320 0010521 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_TAG_OF_09112011_1842) #define BOOST_FUSION_TAG_OF_09112011_1842 #include <boost/fusion/support/config.hpp> #include <tuple> #include <boost/fusion/support/tag_of_fwd.hpp> namespace boost { namespace fusion { struct std_tuple_tag; struct fusion_sequence_tag; namespace traits { template <typename... Elements> struct tag_of<std::tuple<Elements...>> { typedef std_tuple_tag type; }; } }} namespace boost { namespace mpl { template <typename> struct sequence_tag; template <typename... Elements> struct sequence_tag<std::tuple<Elements...>> { typedef fusion::fusion_sequence_tag type; }; template <typename... Elements> struct sequence_tag<std::tuple<Elements...> const> { typedef fusion::fusion_sequence_tag type; }; }} #endif std_tuple/detail/build_std_tuple.hpp 0000644 00000005405 15125731320 0013707 0 ustar 00 /*============================================================================= Copyright (c) 2014 Kohei Takahashi 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BUILD_STD_TUPLE_05292014_0100) #define BOOST_FUSION_BUILD_STD_TUPLE_05292014_0100 #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/detail/index_sequence.hpp> #include <boost/fusion/iterator/equal_to.hpp> #include <boost/fusion/iterator/next.hpp> #include <boost/fusion/iterator/value_of.hpp> #include <boost/fusion/iterator/deref.hpp> #include <tuple> #include <cstddef> namespace boost { namespace fusion { namespace detail { template <typename First, typename Last, bool is_empty = result_of::equal_to<First, Last>::value> struct build_std_tuple; template <typename First, typename Last> struct build_std_tuple<First, Last, true> { typedef std::tuple<> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(First const&, Last const&) { return type(); } }; template <typename T, typename Rest> struct push_front_std_tuple; template <typename T, typename ...Rest> struct push_front_std_tuple<T, std::tuple<Rest...> > { typedef std::tuple<T, Rest...> type; template <std::size_t ...I> BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type indexed_call(T const& first, std::tuple<Rest...> const& rest, index_sequence<I...>) { return type(first, std::get<I>(rest)...); } BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(T const& first, std::tuple<Rest...> const& rest) { typedef typename make_index_sequence<sizeof...(Rest)>::type gen; return indexed_call(first, rest, gen()); } }; template <typename First, typename Last> struct build_std_tuple<First, Last, false> { typedef build_std_tuple<typename result_of::next<First>::type, Last> next_build_std_tuple; typedef push_front_std_tuple< typename result_of::value_of<First>::type , typename next_build_std_tuple::type> push_front; typedef typename push_front::type type; BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(First const& f, Last const& l) { typename result_of::value_of<First>::type v = *f; return push_front::call( v, next_build_std_tuple::call(fusion::next(f), l)); } }; }}} #endif std_tuple/detail/end_impl.hpp 0000644 00000002533 15125731320 0012313 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_END_IMPL_09242011_1744) #define BOOST_FUSION_END_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/std_tuple/std_tuple_iterator.hpp> #include <boost/type_traits/remove_const.hpp> #include <tuple> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename T> struct end_impl; template <> struct end_impl<std_tuple_tag> { template <typename Sequence> struct apply { typedef typename remove_const<Sequence>::type seq_type; static int const size = std::tuple_size<seq_type>::value; typedef std_tuple_iterator<Sequence, size> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& v) { return type(v); } }; }; } }} #endif std_tuple/detail/at_impl.hpp 0000644 00000003225 15125731320 0012150 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_AT_IMPL_09242011_1744) #define BOOST_FUSION_AT_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <tuple> #include <utility> #include <boost/mpl/if.hpp> #include <boost/fusion/support/detail/access.hpp> #include <boost/type_traits/remove_const.hpp> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename T> struct at_impl; template <> struct at_impl<std_tuple_tag> { template <typename Sequence, typename N> struct apply { typedef typename remove_const<Sequence>::type seq_type; typedef typename std::tuple_element<N::value, seq_type>::type element; typedef typename mpl::if_< is_const<Sequence> , typename fusion::detail::cref_result<element>::type , typename fusion::detail::ref_result<element>::type >::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& seq) { return std::get<N::value>(seq); } }; }; } }} #endif std_tuple/detail/convert_impl.hpp 0000644 00000002725 15125731320 0013230 0 ustar 00 /*============================================================================= Copyright (c) 2012-2014 Kohei Takahashi 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CONVERT_IMPL_10172012_0940) #define BOOST_FUSION_CONVERT_IMPL_10172012_0940 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/std_tuple/detail/build_std_tuple.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/sequence/intrinsic/end.hpp> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template <typename T> struct convert_impl; template <> struct convert_impl<std_tuple_tag> { template <typename Sequence> struct apply { typedef detail::build_std_tuple< typename result_of::begin<Sequence>::type , typename result_of::end<Sequence>::type > gen; typedef typename gen::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& seq) { return gen::call(begin(seq), end(seq)); } }; }; } }} #endif std_tuple/detail/value_at_impl.hpp 0000644 00000001611 15125731320 0013341 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_VALUE_AT_IMPL_09242011_1744) #define BOOST_FUSION_VALUE_AT_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <tuple> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename T> struct value_at_impl; template <> struct value_at_impl<std_tuple_tag> { template <typename Sequence, typename N> struct apply : std::tuple_element<N::value, Sequence> {}; }; } }} #endif std_tuple/detail/begin_impl.hpp 0000644 00000002217 15125731320 0012630 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BEGIN_IMPL_09242011_1744) #define BOOST_FUSION_BEGIN_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/std_tuple/std_tuple_iterator.hpp> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename T> struct begin_impl; template <> struct begin_impl<std_tuple_tag> { template <typename Sequence> struct apply { typedef std_tuple_iterator<Sequence, 0> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& v) { return type(v); } }; }; } }} #endif std_tuple/detail/size_impl.hpp 0000644 00000002034 15125731320 0012513 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_SIZE_IMPL_09242011_1744) #define BOOST_FUSION_SIZE_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <tuple> #include <boost/mpl/int.hpp> #include <boost/type_traits/remove_const.hpp> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename T> struct size_impl; template <> struct size_impl<std_tuple_tag> { template <typename Sequence> struct apply : mpl::int_<std::tuple_size< typename remove_const<Sequence>::type>::value > {}; }; } }} #endif std_tuple/detail/is_sequence_impl.hpp 0000644 00000001572 15125731320 0014052 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_SEQUENCE_IMPL_09242011_1744) #define BOOST_FUSION_IS_SEQUENCE_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename Tag> struct is_sequence_impl; template<> struct is_sequence_impl<std_tuple_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; } }} #endif std_tuple/detail/is_view_impl.hpp 0000644 00000001544 15125731320 0013213 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_VIEW_IMPL_09242011_1744) #define BOOST_FUSION_IS_VIEW_IMPL_09242011_1744 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct std_tuple_tag; namespace extension { template<typename Tag> struct is_view_impl; template<> struct is_view_impl<std_tuple_tag> { template<typename T> struct apply : mpl::false_ {}; }; } }} #endif std_tuple/detail/category_of_impl.hpp 0000644 00000001625 15125731320 0014047 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CATEGORY_OF_IMPL_04202013_0940) #define BOOST_FUSION_CATEGORY_OF_IMPL_04202013_0940 namespace boost { namespace fusion { struct std_tuple_tag; struct random_access_traversal_tag; namespace extension { template<typename T> struct category_of_impl; template<> struct category_of_impl<std_tuple_tag> { template<typename T> struct apply { typedef random_access_traversal_tag type; }; }; } }} #endif std_array/tag_of.hpp 0000644 00000002556 15125731320 0010513 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_TAG_OF_01062013_1700) #define BOOST_FUSION_STD_ARRAY_TAG_OF_01062013_1700 #include <boost/fusion/support/tag_of_fwd.hpp> #include <array> #include <cstddef> namespace boost { namespace fusion { struct std_array_tag; struct fusion_sequence_tag; namespace traits { template<typename T, std::size_t N> #if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) struct tag_of<std::array<T,N>, void > #else struct tag_of<std::array<T,N> > #endif { typedef std_array_tag type; }; } }} namespace boost { namespace mpl { template<typename> struct sequence_tag; template<typename T, std::size_t N> struct sequence_tag<std::array<T,N> > { typedef fusion::fusion_sequence_tag type; }; template<typename T, std::size_t N> struct sequence_tag<std::array<T,N> const> { typedef fusion::fusion_sequence_tag type; }; }} #endif std_array/std_array_iterator.hpp 0000644 00000006346 15125731320 0013156 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_ARRAY_ITERATOR_01062013_1700) #define BOOST_FUSION_STD_ARRAY_ARRAY_ITERATOR_01062013_1700 #include <cstddef> #include <boost/config.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/minus.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/fusion/iterator/iterator_facade.hpp> #include <boost/fusion/adapted/std_array/detail/array_size.hpp> namespace boost { namespace fusion { struct random_access_traversal_tag; template <typename Array, int Pos> struct std_array_iterator : iterator_facade<std_array_iterator<Array, Pos>, random_access_traversal_tag> { BOOST_MPL_ASSERT_RELATION(Pos, >=, 0); BOOST_MPL_ASSERT_RELATION(Pos, <=, std::tuple_size<Array>::value); typedef mpl::int_<Pos> index; typedef Array array_type; std_array_iterator(Array& a) : array(a) {} Array& array; template <typename Iterator> struct value_of { typedef typename Iterator::array_type array_type; typedef typename array_type::value_type type; }; template <typename Iterator> struct deref { typedef typename Iterator::array_type array_type; typedef typename mpl::if_< is_const<array_type> , typename array_type::const_reference , typename array_type::reference >::type type; static type call(Iterator const & it) { return it.array[Iterator::index::value]; } }; template <typename Iterator, typename N> struct advance { typedef typename Iterator::index index; typedef typename Iterator::array_type array_type; typedef std_array_iterator<array_type, index::value + N::value> type; static type call(Iterator const& i) { return type(i.array); } }; template <typename Iterator> struct next : advance<Iterator, mpl::int_<1> > {}; template <typename Iterator> struct prior : advance<Iterator, mpl::int_<-1> > {}; template <typename I1, typename I2> struct distance : mpl::minus<typename I2::index, typename I1::index> { typedef typename mpl::minus< typename I2::index, typename I1::index >::type type; static type call(I1 const&, I2 const&) { return type(); } }; BOOST_DELETED_FUNCTION(std_array_iterator& operator=(std_array_iterator const&)) }; }} #endif std_array/detail/end_impl.hpp 0000644 00000002623 15125731320 0012300 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_END_OF_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_END_OF_IMPL_01062013_1700 #include <boost/fusion/adapted/std_array/std_array_iterator.hpp> #include <boost/fusion/adapted/std_array/detail/array_size.hpp> #include <boost/type_traits/remove_const.hpp> namespace boost { namespace fusion { struct std_array_tag; namespace extension { template <typename Tag> struct end_impl; template <> struct end_impl<std_array_tag> { template <typename Sequence> struct apply { typedef typename remove_const<Sequence>::type seq_type; static int const size = std_array_size<seq_type>::value; typedef std_array_iterator<Sequence, size> type; static type call(Sequence& v) { return type(v); } }; }; } }} #endif std_array/detail/array_size.hpp 0000644 00000001544 15125731320 0012662 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_ARRAY_SIZE_01062013_1700) #define BOOST_FUSION_STD_ARRAY_ARRAY_SIZE_01062013_1700 #include <cstddef> #include <boost/type_traits/integral_constant.hpp> namespace boost { namespace fusion { namespace extension { template<class T> struct std_array_size; template<template<typename, std::size_t> class Array, typename T, std::size_t N> struct std_array_size<Array<T, N> > : boost::integral_constant<std::size_t, N> {}; } }} #endif std_array/detail/at_impl.hpp 0000644 00000002406 15125731320 0012135 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_AT_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_AT_IMPL_01062013_1700 #include <boost/type_traits/is_const.hpp> #include <boost/mpl/if.hpp> namespace boost { namespace fusion { struct std_array_tag; namespace extension { template<typename T> struct at_impl; template<> struct at_impl<std_array_tag> { template<typename Sequence, typename N> struct apply { typedef typename mpl::if_< is_const<Sequence>, typename Sequence::const_reference, typename Sequence::reference>::type type; static type call(Sequence& seq) { return seq[N::value]; } }; }; } }} #endif std_array/detail/value_at_impl.hpp 0000644 00000001673 15125731320 0013336 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_VALUE_AT_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_VALUE_AT_IMPL_01062013_1700 namespace boost { namespace fusion { struct std_array_tag; namespace extension { template<typename T> struct value_at_impl; template <> struct value_at_impl<std_array_tag> { template <typename Sequence, typename N> struct apply { typedef typename Sequence::value_type type; }; }; } }} #endif std_array/detail/begin_impl.hpp 0000644 00000002241 15125731320 0012612 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_BEGIN_OF_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_BEGIN_OF_IMPL_01062013_1700 #include <boost/fusion/adapted/std_array/std_array_iterator.hpp> namespace boost { namespace fusion { struct std_array_tag; namespace extension { template<typename T> struct begin_impl; template <> struct begin_impl<std_array_tag> { template <typename Sequence> struct apply { typedef std_array_iterator<Sequence, 0> type; static type call(Sequence& v) { return type(v); } }; }; } }} #endif std_array/detail/size_impl.hpp 0000644 00000002320 15125731320 0012476 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_SIZE_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_SIZE_IMPL_01062013_1700 #include <boost/fusion/adapted/std_array/detail/array_size.hpp> #include <boost/type_traits/remove_const.hpp> namespace boost { namespace fusion { struct std_array_tag; namespace extension { template<typename T> struct size_impl; template<> struct size_impl<std_array_tag> { template<typename Sequence> struct apply : mpl::int_ < std_array_size < typename remove_const<Sequence>::type >::value > {}; }; } }} #endif std_array/detail/is_sequence_impl.hpp 0000644 00000001663 15125731320 0014040 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_IS_SEQUENCE_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_IS_SEQUENCE_IMPL_01062013_1700 #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct std_array_tag; namespace extension { template<typename Tag> struct is_sequence_impl; template<> struct is_sequence_impl<std_array_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; } }} #endif std_array/detail/is_view_impl.hpp 0000644 00000001651 15125731320 0013177 0 ustar 00 /*============================================================================= Copyright (c) 2013 Mateusz Loskot Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_IS_VIEW_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_IS_VIEW_IMPL_01062013_1700 #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct std_array_tag; namespace extension { template<typename Tag> struct is_view_impl; template<> struct is_view_impl<std_array_tag> { template<typename T> struct apply : mpl::false_ {}; }; } }} #endif std_array/detail/category_of_impl.hpp 0000644 00000002000 15125731320 0014020 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_STD_ARRAY_CATEGORY_OF_IMPL_01062013_1700) #define BOOST_FUSION_STD_ARRAY_CATEGORY_OF_IMPL_01062013_1700 #include <boost/config/no_tr1/utility.hpp> namespace boost { namespace fusion { struct std_array_tag; struct random_access_traversal_tag; namespace extension { template<typename T> struct category_of_impl; template<> struct category_of_impl<std_array_tag> { template<typename T> struct apply { typedef random_access_traversal_tag type; }; }; } }} #endif boost_array.hpp 0000644 00000006325 15125731320 0007606 0 ustar 00 // Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2010 Alfredo Correa // Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands. // This file was modified by Oracle on 2020. // Modifications copyright (c) 2020 Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Use, modification and distribution is subject to 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_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_ARRAY_HPP #define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_ARRAY_HPP #ifdef BOOST_GEOMETRY_ADAPTED_BOOST_ARRAY_TAG_DEFINED #error Include either "boost_array_as_point" or \ "boost_array_as_linestring" or "boost_array_as_ring" \ or "boost_array_as_multi_point" to adapt a boost_array #endif #define BOOST_GEOMETRY_ADAPTED_BOOST_ARRAY_TAG_DEFINED #include <cstddef> #include <type_traits> #include <boost/geometry/core/access.hpp> #include <boost/geometry/core/cs.hpp> #include <boost/geometry/core/coordinate_dimension.hpp> #include <boost/geometry/core/coordinate_type.hpp> #include <boost/geometry/core/tags.hpp> #include <boost/array.hpp> namespace boost { namespace geometry { #ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS namespace traits { #ifndef DOXYGEN_NO_DETAIL namespace detail { // Create class and specialization to indicate the tag // for normal cases and the case that the type of the c-array is arithmetic template <bool> struct boost_array_tag { typedef geometry_not_recognized_tag type; }; template <> struct boost_array_tag<true> { typedef point_tag type; }; } // namespace detail #endif // DOXYGEN_NO_DETAIL // Assign the point-tag, preventing arrays of points getting a point-tag template <typename CoordinateType, std::size_t DimensionCount> struct tag<boost::array<CoordinateType, DimensionCount> > : detail::boost_array_tag<std::is_arithmetic<CoordinateType>::value> {}; template <typename CoordinateType, std::size_t DimensionCount> struct coordinate_type<boost::array<CoordinateType, DimensionCount> > { typedef CoordinateType type; }; template <typename CoordinateType, std::size_t DimensionCount> struct dimension<boost::array<CoordinateType, DimensionCount> > : std::integral_constant<std::size_t, DimensionCount> {}; template <typename CoordinateType, std::size_t DimensionCount, std::size_t Dimension> struct access<boost::array<CoordinateType, DimensionCount>, Dimension> { static inline CoordinateType get(boost::array<CoordinateType, DimensionCount> const& a) { return a[Dimension]; } static inline void set(boost::array<CoordinateType, DimensionCount>& a, CoordinateType const& value) { a[Dimension] = value; } }; } // namespace traits #endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS }} // namespace boost::geometry #define BOOST_GEOMETRY_REGISTER_BOOST_ARRAY_CS(CoordinateSystem) \ namespace boost { namespace geometry { namespace traits { \ template <class T, std::size_t N> \ struct coordinate_system<boost::array<T, N> > \ { \ typedef CoordinateSystem type; \ }; \ }}} #endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_ARRAY_HPP boost_array/array_iterator.hpp 0000644 00000007026 15125731320 0012634 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_ARRAY_ITERATOR_26122005_2250) #define BOOST_FUSION_ARRAY_ITERATOR_26122005_2250 #include <boost/fusion/support/config.hpp> #include <cstddef> #include <boost/config.hpp> #include <boost/mpl/int.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/minus.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/fusion/iterator/iterator_facade.hpp> namespace boost { namespace fusion { struct random_access_traversal_tag; template <typename Array, int Pos> struct array_iterator : iterator_facade<array_iterator<Array, Pos>, random_access_traversal_tag> { BOOST_MPL_ASSERT_RELATION(Pos, >=, 0); BOOST_MPL_ASSERT_RELATION(Pos, <=, static_cast<int>(Array::static_size)); typedef mpl::int_<Pos> index; typedef Array array_type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED array_iterator(Array& a) : array(a) {} Array& array; template <typename Iterator> struct value_of { typedef typename Iterator::array_type array_type; typedef typename array_type::value_type type; }; template <typename Iterator> struct deref { typedef typename Iterator::array_type array_type; typedef typename mpl::if_< is_const<array_type> , typename array_type::const_reference , typename array_type::reference >::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator const & it) { return it.array[Iterator::index::value]; } }; template <typename Iterator, typename N> struct advance { typedef typename Iterator::index index; typedef typename Iterator::array_type array_type; typedef array_iterator<array_type, index::value + N::value> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Iterator const& i) { return type(i.array); } }; template <typename Iterator> struct next : advance<Iterator, mpl::int_<1> > {}; template <typename Iterator> struct prior : advance<Iterator, mpl::int_<-1> > {}; template <typename I1, typename I2> struct distance : mpl::minus<typename I2::index, typename I1::index> { typedef typename mpl::minus< typename I2::index, typename I1::index >::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(I1 const&, I2 const&) { return type(); } }; BOOST_DELETED_FUNCTION(array_iterator& operator=(array_iterator const&)) }; }} #ifdef BOOST_FUSION_WORKAROUND_FOR_LWG_2408 namespace std { template <typename Array, int Pos> struct iterator_traits< ::boost::fusion::array_iterator<Array, Pos> > { }; } #endif #endif boost_array/tag_of.hpp 0000644 00000002712 15125731320 0011041 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(FUSION_SEQUENCE_TAG_OF_27122005_1030) #define FUSION_SEQUENCE_TAG_OF_27122005_1030 #include <boost/fusion/support/config.hpp> #include <boost/fusion/support/tag_of_fwd.hpp> #include <cstddef> namespace boost { template<typename T, std::size_t N> class array; } namespace boost { namespace fusion { struct boost_array_tag; struct fusion_sequence_tag; namespace traits { template<typename T, std::size_t N> #if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) struct tag_of<boost::array<T,N>, void > #else struct tag_of<boost::array<T,N> > #endif { typedef boost_array_tag type; }; } }} namespace boost { namespace mpl { template<typename> struct sequence_tag; template<typename T, std::size_t N> struct sequence_tag<array<T,N> > { typedef fusion::fusion_sequence_tag type; }; template<typename T, std::size_t N> struct sequence_tag<array<T,N> const> { typedef fusion::fusion_sequence_tag type; }; }} #endif boost_array/detail/end_impl.hpp 0000644 00000002306 15125731320 0012632 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_END_IMPL_27122005_1120) #define BOOST_FUSION_END_IMPL_27122005_1120 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/boost_array/array_iterator.hpp> namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template <typename Tag> struct end_impl; template <> struct end_impl<boost_array_tag> { template <typename Sequence> struct apply { typedef array_iterator<Sequence, Sequence::static_size> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& v) { return type(v); } }; }; } }} #endif boost_array/detail/at_impl.hpp 0000644 00000002526 15125731320 0012474 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_AT_IMPL_27122005_1241) #define BOOST_FUSION_AT_IMPL_27122005_1241 #include <boost/fusion/support/config.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/mpl/if.hpp> namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template<typename T> struct at_impl; template<> struct at_impl<boost_array_tag> { template<typename Sequence, typename N> struct apply { typedef typename mpl::if_< is_const<Sequence>, typename Sequence::const_reference, typename Sequence::reference>::type type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& seq) { return seq[N::value]; } }; }; } }} #endif boost_array/detail/value_at_impl.hpp 0000644 00000001653 15125731320 0013670 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_VALUE_AT_IMPL_27122005_1256) #define BOOST_FUSION_VALUE_AT_IMPL_27122005_1256 namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template<typename T> struct value_at_impl; template <> struct value_at_impl<boost_array_tag> { template <typename Sequence, typename N> struct apply { typedef typename Sequence::value_type type; }; }; } }} #endif boost_array/detail/begin_impl.hpp 0000644 00000002267 15125731320 0013156 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BEGIN_IMPL_27122005_1117) #define BOOST_FUSION_BEGIN_IMPL_27122005_1117 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/boost_array/array_iterator.hpp> namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template<typename T> struct begin_impl; template <> struct begin_impl<boost_array_tag> { template <typename Sequence> struct apply { typedef array_iterator<Sequence, 0> type; BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED static type call(Sequence& v) { return type(v); } }; }; } }} #endif boost_array/detail/size_impl.hpp 0000644 00000001526 15125731320 0013041 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_SIZE_IMPL_27122005_1251) #define BOOST_FUSION_SIZE_IMPL_27122005_1251 namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template<typename T> struct size_impl; template<> struct size_impl<boost_array_tag> { template<typename Sequence> struct apply : mpl::int_<Sequence::static_size> {}; }; } }} #endif boost_array/detail/is_sequence_impl.hpp 0000644 00000001650 15125731320 0014370 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_SEQUENCE_IMPL_27122005_1648) #define BOOST_FUSION_IS_SEQUENCE_IMPL_27122005_1648 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template<typename Tag> struct is_sequence_impl; template<> struct is_sequence_impl<boost_array_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; } }} #endif boost_array/detail/is_view_impl.hpp 0000644 00000001636 15125731320 0013536 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_IS_VIEW_IMPL_27042006_2221) #define BOOST_FUSION_IS_VIEW_IMPL_27042006_2221 #include <boost/fusion/support/config.hpp> #include <boost/mpl/bool.hpp> namespace boost { namespace fusion { struct boost_array_tag; namespace extension { template<typename Tag> struct is_view_impl; template<> struct is_view_impl<boost_array_tag> { template<typename T> struct apply : mpl::false_ {}; }; } }} #endif boost_array/detail/category_of_impl.hpp 0000644 00000002033 15125731320 0014362 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden 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) ==============================================================================*/ #if !defined(BOOST_FUSION_CATEGORY_OF_IMPL_27122005_1044) #define BOOST_FUSION_CATEGORY_OF_IMPL_27122005_1044 #include <boost/fusion/support/config.hpp> #include <boost/config/no_tr1/utility.hpp> namespace boost { namespace fusion { struct boost_array_tag; struct random_access_traversal_tag; namespace extension { template<typename T> struct category_of_impl; template<> struct category_of_impl<boost_array_tag> { template<typename T> struct apply { typedef random_access_traversal_tag type; }; }; } }} #endif std_tuple.hpp 0000644 00000002373 15125731320 0007264 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman 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) ==============================================================================*/ #if !defined(BOOST_FUSION_BOOST_TUPLE_09242011_1744) #define BOOST_FUSION_BOOST_TUPLE_09242011_1744 #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/std_tuple/detail/is_view_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/is_sequence_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/category_of_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/begin_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/end_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/size_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/at_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/value_at_impl.hpp> #include <boost/fusion/adapted/std_tuple/detail/convert_impl.hpp> #include <boost/fusion/adapted/std_tuple/std_tuple_iterator.hpp> #include <boost/fusion/adapted/std_tuple/tag_of.hpp> #include <boost/fusion/adapted/std_tuple/mpl/clear.hpp> #endif std_pair.hpp 0000644 00000001356 15125731320 0007066 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2009-2010 Christopher Schmidt 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_FUSION_ADAPTED_STD_PAIR_HPP #define BOOST_FUSION_ADAPTED_STD_PAIR_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/adapt_struct.hpp> #include <utility> BOOST_FUSION_ADAPT_TPL_STRUCT( (T1)(T2),(std::pair)(T1)(T2),(T1, first)(T2, second)) #endif adt.hpp 0000644 00000001432 15125731320 0006024 0 ustar 00 /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ADT_HPP #define BOOST_FUSION_ADAPTED_ADT_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/adt/adapt_assoc_adt_named.hpp> #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp> #include <boost/fusion/adapted/adt/adapt_adt_named.hpp> #include <boost/fusion/adapted/adt/adapt_adt.hpp> #endif adt/adapt_adt.hpp 0000644 00000010665 15125731320 0007755 0 ustar 00 /*============================================================================= Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2009-2010 Hartmut Kaiser Copyright (c) 2010-2011 Christopher Schmidt Copyright (c) 2013-2014 Damien Buhl 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_FUSION_ADAPTED_ADT_ADAPT_ADT_HPP #define BOOST_FUSION_ADAPTED_ADT_ADAPT_ADT_HPP #include <boost/fusion/support/config.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/empty.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/comparison/less.hpp> #include <boost/fusion/adapted/struct/detail/extension.hpp> #include <boost/fusion/adapted/struct/detail/adapt_base.hpp> #include <boost/fusion/adapted/struct/detail/at_impl.hpp> #include <boost/fusion/adapted/struct/detail/is_view_impl.hpp> #include <boost/fusion/adapted/struct/detail/proxy_type.hpp> #include <boost/fusion/adapted/struct/detail/is_sequence_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_at_impl.hpp> #include <boost/fusion/adapted/struct/detail/category_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/size_impl.hpp> #include <boost/fusion/adapted/struct/detail/begin_impl.hpp> #include <boost/fusion/adapted/struct/detail/end_impl.hpp> #include <boost/fusion/adapted/struct/detail/value_of_impl.hpp> #include <boost/fusion/adapted/struct/detail/deref_impl.hpp> #include <boost/fusion/adapted/adt/detail/extension.hpp> #include <boost/fusion/adapted/adt/detail/adapt_base.hpp> #include <boost/fusion/adapted/adt/detail/adapt_base_attr_filler.hpp> #define BOOST_FUSION_ADAPT_ADT_C( \ TEMPLATE_PARAMS_SEQ, NAME_SEQ, IS_VIEW, I, ATTRIBUTE) \ BOOST_FUSION_ADAPT_ADT_C_BASE( \ TEMPLATE_PARAMS_SEQ, \ NAME_SEQ, \ I, \ BOOST_PP_IIF(IS_VIEW, BOOST_FUSION_PROXY_PREFIX, BOOST_PP_EMPTY), \ BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR(ATTRIBUTE), \ BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), \ BOOST_PP_LESS( \ BOOST_FUSION_ADAPT_ADT_WRAPPEDATTR_SIZE(ATTRIBUTE), 4)) \ #define BOOST_FUSION_ADAPT_TPL_ADT(TEMPLATE_PARAMS_SEQ, NAME_SEQ , ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (1)TEMPLATE_PARAMS_SEQ, \ (1)NAME_SEQ, \ struct_tag, \ 0, \ BOOST_PP_CAT(BOOST_FUSION_ADAPT_ADT_FILLER_0(0,0,0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_ADT_C) #define BOOST_FUSION_ADAPT_ADT(NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(NAME), \ struct_tag, \ 0, \ BOOST_PP_CAT(BOOST_FUSION_ADAPT_ADT_FILLER_0(0,0,0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_ADT_C) #define BOOST_FUSION_ADAPT_ADT_AS_VIEW(NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_STRUCT_BASE( \ (0), \ (0)(NAME), \ struct_tag, \ 1, \ BOOST_PP_CAT(BOOST_FUSION_ADAPT_ADT_FILLER_0(0,0,0,0)ATTRIBUTES,_END), \ BOOST_FUSION_ADAPT_ADT_C) #endif adt/adapt_assoc_adt_named.hpp 0000644 00000003021 15125731320 0012275 0 ustar 00 /*============================================================================= Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ADT_ADAPT_ASSOC_ADT_NAMED_HPP #define BOOST_FUSION_ADAPTED_ADT_ADAPT_ASSOC_ADT_NAMED_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp> #include <boost/fusion/adapted/struct/detail/proxy_type.hpp> #define BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED_NS( \ WRAPPED_TYPE, NAMESPACE_SEQ, NAME, ATTRIBUTES) \ \ BOOST_FUSION_ADAPT_STRUCT_DEFINE_PROXY_TYPE_IMPL( \ WRAPPED_TYPE,(0)NAMESPACE_SEQ,NAME) \ \ BOOST_FUSION_ADAPT_ASSOC_ADT_AS_VIEW( \ BOOST_FUSION_ADAPT_STRUCT_NAMESPACE_DECLARATION((0)NAMESPACE_SEQ)NAME, \ ATTRIBUTES) #define BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(WRAPPED_TYPE, NAME, ATTRIBUTES) \ BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED_NS( \ WRAPPED_TYPE,(boost)(fusion)(adapted),NAME,ATTRIBUTES) #endif adt/detail/adapt_base.hpp 0000644 00000050723 15125731320 0011360 0 ustar 00 /*============================================================================= Copyright (c) 2001-2009 Joel de Guzman Copyright (c) 2005-2006 Dan Marsden Copyright (c) 2010 Christopher Schmidt 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_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_HPP #define BOOST_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_HPP #include <boost/fusion/support/config.hpp> #include <boost/fusion/adapted/struct/detail/adapt_auto.hpp> #include <boost/fusion/adapted/struct/detail/adapt_is_tpl.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/control/expr_if.hpp> #include <boost/preprocessor/seq/seq.hpp> #include <boost/preprocessor/seq/elem.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/typeof/typeof.hpp> #define BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_TEMPLATE_IMPL(TEMPLATE_PARAMS_SEQ) \ typename detail::get_identity< \ lvalue \ , BOOST_PP_SEQ_ELEM(1,TEMPLATE_PARAMS_SEQ) \ >::type #define BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_NON_TEMPLATE_IMPL( \ TEMPLATE_PARAMS_SEQ) \ \ boost::remove_const<boost::remove_reference<lvalue>::type>::type #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \ ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, \ BOOST_PP_IF(DEDUCE_TYPE, 0, 2), ATTRIBUTE) #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE, \ ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE) \ BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, \ BOOST_PP_IF(DEDUCE_TYPE, 1, 3), ATTRIBUTE) #ifdef BOOST_MSVC # define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE, \ ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \ \ BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS( \ TEMPLATE_PARAMS_SEQ) \ \ struct deduced_attr_type { \ static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.01 |
proxy
|
phpinfo
|
???????????