1 /*=============================================================================
2 Copyright (c) 2001-2014 Joel de Guzman
3 Copyright (c) 2013 Agustin Berge
4 http://spirit.sourceforge.net/
6 Distributed under the Boost Software License, Version 1.0. (See accompanying
7 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8 =============================================================================*/
9 #if !defined(BOOST_SPIRIT_X3_MOVE_TO_JAN_17_2013_0859PM)
10 #define BOOST_SPIRIT_X3_MOVE_TO_JAN_17_2013_0859PM
12 #include <boost/spirit/home/x3/support/traits/attribute_category.hpp>
13 #include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
14 #include <boost/spirit/home/x3/support/traits/variant_has_substitute.hpp>
15 #include <boost/fusion/include/is_sequence.hpp>
16 #include <boost/fusion/include/front.hpp>
17 #include <boost/fusion/include/size.hpp>
18 #include <boost/fusion/include/move.hpp>
19 #include <boost/fusion/include/is_sequence.hpp>
20 #include <boost/range/iterator_range.hpp>
23 namespace boost { namespace spirit { namespace x3 { namespace traits
25 template <typename Source, typename Dest>
26 inline void move_to(Source&& src, Dest& dest);
29 inline void move_to(T& src, T& dest);
32 inline void move_to(T const& src, T& dest);
35 inline void move_to(T&& src, T& dest);
37 template <typename Iterator, typename Dest>
38 inline void move_to(Iterator first, Iterator last, Dest& dest);
40 template <typename Dest>
41 inline void move_to(unused_type, Dest&) {}
43 template <typename Source>
44 inline void move_to(Source&, unused_type) {}
46 inline void move_to(unused_type, unused_type) {}
48 template <typename Iterator>
50 move_to(Iterator, Iterator, unused_type) {}
54 template <typename Source, typename Dest>
56 move_to(Source&&, Dest&, unused_attribute) {}
58 template <typename Source, typename Dest>
60 move_to_plain(Source&& src, Dest& dest, mpl::false_) // src is not a single-element tuple
62 dest = std::move(src);
65 template <typename Source, typename Dest>
67 move_to_plain(Source&& src, Dest& dest, mpl::true_) // src is a single-element tuple
69 dest = std::move(fusion::front(src));
72 template <typename Source, typename Dest>
74 move_to(Source&& src, Dest& dest, plain_attribute)
77 fusion::traits::is_sequence<Source>,
78 is_size_one_sequence<Source> >
79 is_single_element_sequence;
81 move_to_plain(std::forward<Source>(src), dest, is_single_element_sequence);
84 template <typename Source, typename Dest>
85 inline typename enable_if<is_container<Source>>::type
86 move_to(Source&& src, Dest& dest, container_attribute)
88 traits::move_to(src.begin(), src.end(), dest);
91 template <typename Source, typename Dest>
92 inline typename enable_if<
94 is_same_size_sequence<Dest, Source>,
95 mpl::not_<is_size_one_sequence<Dest> > >
97 move_to(Source&& src, Dest& dest, tuple_attribute)
99 fusion::move(std::forward<Source>(src), dest);
102 template <typename Source, typename Dest>
103 inline typename enable_if<
104 is_size_one_sequence<Dest>
106 move_to(Source&& src, Dest& dest, tuple_attribute)
108 traits::move_to(std::forward<Source>(src), fusion::front(dest));
111 template <typename Source, typename Dest>
113 move_to(Source&& src, Dest& dest, variant_attribute, mpl::false_)
115 dest = std::move(src);
118 template <typename Source, typename Dest>
120 move_to_variant_from_single_element_sequence(Source&& src, Dest& dest, mpl::false_)
122 // dest is a variant, src is a single element fusion sequence that the variant
123 // cannot directly hold. We'll try to unwrap the single element fusion sequence.
125 // Make sure that the Dest variant can really hold Source
126 static_assert(variant_has_substitute<Dest, typename fusion::result_of::front<Source>::type>::value,
127 "Error! The destination variant (Dest) cannot hold the source type (Source)");
129 dest = std::move(fusion::front(src));
132 template <typename Source, typename Dest>
134 move_to_variant_from_single_element_sequence(Source&& src, Dest& dest, mpl::true_)
136 // dest is a variant, src is a single element fusion sequence that the variant
137 // *can* directly hold.
138 dest = std::move(src);
141 template <typename Source, typename Dest>
143 move_to(Source&& src, Dest& dest, variant_attribute, mpl::true_)
145 move_to_variant_from_single_element_sequence(src, dest, variant_has_substitute<Dest, Source>());
148 template <typename Source, typename Dest>
150 move_to(Source&& src, Dest& dest, variant_attribute tag)
152 move_to(src, dest, tag, is_size_one_sequence<Source>());
155 template <typename Iterator>
157 move_to(Iterator, Iterator, unused_type, unused_attribute) {}
159 template <typename Iterator, typename Dest>
161 move_to(Iterator first, Iterator last, Dest& dest, container_attribute)
164 dest = Dest(first, last);
166 append(dest, first, last);
169 template <typename Iterator>
171 move_to(Iterator first, Iterator last, boost::iterator_range<Iterator>& rng, container_attribute)
177 template <typename Source, typename Dest>
178 inline void move_to(Source&& src, Dest& dest)
180 detail::move_to(std::move(src), dest
181 , typename attribute_category<Dest>::type());
184 template <typename T>
185 inline void move_to(T& src, T& dest)
187 if (boost::addressof(src) != boost::addressof(dest))
188 dest = std::move(src);
191 template <typename T>
192 inline void move_to(T const& src, T& dest)
194 if (boost::addressof(src) != boost::addressof(dest))
195 dest = std::move(src);
198 template <typename T>
199 inline void move_to(T&& src, T& dest)
201 if (boost::addressof(src) != boost::addressof(dest))
202 dest = std::move(src);
205 template <typename Iterator, typename Dest>
206 inline void move_to(Iterator first, Iterator last, Dest& dest)
208 // $$$ Use std::move_iterator when iterator is not a const-iterator $$$
209 detail::move_to(first, last, dest, typename attribute_category<Dest>::type());