ceph/src/boost/libs/spirit/include/boost/spirit/home/x3/support/traits/move_to.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2014 Joel de Guzman
   3     Copyright (c) 2013 Agustin Berge
   4     http://spirit.sourceforge.net/
   5
   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
  11
  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>
  21 #include <utility>
  22
  23 namespace boost { namespace spirit { namespace x3 { namespace traits
  24 {
  25     template <typename Source, typename Dest>
  26     inline void move_to(Source&& src, Dest& dest);
  27
  28     template <typename T>
  29     inline void move_to(T& src, T& dest);
  30
  31     template <typename T>
  32     inline void move_to(T const& src, T& dest);
  33
  34     template <typename T>
  35     inline void move_to(T&& src, T& dest);
  36
  37     template <typename Iterator, typename Dest>
  38     inline void move_to(Iterator first, Iterator last, Dest& dest);
  39
  40     template <typename Dest>
  41     inline void move_to(unused_type, Dest&) {}
  42
  43     template <typename Source>
  44     inline void move_to(Source&, unused_type) {}
  45
  46     inline void move_to(unused_type, unused_type) {}
  47
  48     template <typename Iterator>
  49     inline void
  50     move_to(Iterator, Iterator, unused_type) {}
  51
  52     namespace detail
  53     {
  54         template <typename Source, typename Dest>
  55         inline void
  56         move_to(Source&&, Dest&, unused_attribute) {}
  57
  58         template <typename Source, typename Dest>
  59         inline void
  60         move_to_plain(Source&& src, Dest& dest, mpl::false_) // src is not a single-element tuple
  61         {
  62             dest = std::move(src);
  63         }
  64
  65         template <typename Source, typename Dest>
  66         inline void
  67         move_to_plain(Source&& src, Dest& dest, mpl::true_) // src is a single-element tuple
  68         {
  69             dest = std::move(fusion::front(src));
  70         }
  71
  72         template <typename Source, typename Dest>
  73         inline void
  74         move_to(Source&& src, Dest& dest, plain_attribute)
  75         {
  76             typename mpl::and_<
  77                 fusion::traits::is_sequence<Source>,
  78                 is_size_one_sequence<Source> >
  79             is_single_element_sequence;
  80
  81             move_to_plain(std::forward<Source>(src), dest, is_single_element_sequence);
  82         }
  83
  84         template <typename Source, typename Dest>
  85         inline typename enable_if<is_container<Source>>::type
  86         move_to(Source&& src, Dest& dest, container_attribute)
  87         {
  88             traits::move_to(src.begin(), src.end(), dest);
  89         }
  90
  91         template <typename Source, typename Dest>
  92         inline typename enable_if<
  93             mpl::and_<
  94                 is_same_size_sequence<Dest, Source>,
  95                 mpl::not_<is_size_one_sequence<Dest> > >
  96         >::type
  97         move_to(Source&& src, Dest& dest, tuple_attribute)
  98         {
  99             fusion::move(std::forward<Source>(src), dest);
 100         }
 101
 102         template <typename Source, typename Dest>
 103         inline typename enable_if<
 104             is_size_one_sequence<Dest>
 105         >::type
 106         move_to(Source&& src, Dest& dest, tuple_attribute)
 107         {
 108             traits::move_to(std::forward<Source>(src), fusion::front(dest));
 109         }
 110
 111         template <typename Source, typename Dest>
 112         inline void
 113         move_to(Source&& src, Dest& dest, variant_attribute, mpl::false_)
 114         {
 115             dest = std::move(src);
 116         }
 117
 118         template <typename Source, typename Dest>
 119         inline void
 120         move_to_variant_from_single_element_sequence(Source&& src, Dest& dest, mpl::false_)
 121         {
 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.
 124
 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)");
 128
 129             dest = std::move(fusion::front(src));
 130         }
 131
 132         template <typename Source, typename Dest>
 133         inline void
 134         move_to_variant_from_single_element_sequence(Source&& src, Dest& dest, mpl::true_)
 135         {
 136             // dest is a variant, src is a single element fusion sequence that the variant
 137             // *can* directly hold.
 138             dest = std::move(src);
 139         }
 140
 141         template <typename Source, typename Dest>
 142         inline void
 143         move_to(Source&& src, Dest& dest, variant_attribute, mpl::true_)
 144         {
 145             move_to_variant_from_single_element_sequence(src, dest, variant_has_substitute<Dest, Source>());
 146         }
 147
 148         template <typename Source, typename Dest>
 149         inline void
 150         move_to(Source&& src, Dest& dest, variant_attribute tag)
 151         {
 152             move_to(src, dest, tag, is_size_one_sequence<Source>());
 153         }
 154
 155         template <typename Iterator>
 156         inline void
 157         move_to(Iterator, Iterator, unused_type, unused_attribute) {}
 158
 159         template <typename Iterator, typename Dest>
 160         inline void
 161         move_to(Iterator first, Iterator last, Dest& dest, container_attribute)
 162         {
 163             if (is_empty(dest))
 164                 dest = Dest(first, last);
 165             else
 166                 append(dest, first, last);
 167         }
 168
 169         template <typename Iterator>
 170         inline void
 171         move_to(Iterator first, Iterator last, boost::iterator_range<Iterator>& rng, container_attribute)
 172         {
 173             rng = {first, last};
 174         }
 175     }
 176
 177     template <typename Source, typename Dest>
 178     inline void move_to(Source&& src, Dest& dest)
 179     {
 180         detail::move_to(std::move(src), dest
 181           , typename attribute_category<Dest>::type());
 182     }
 183
 184     template <typename T>
 185     inline void move_to(T& src, T& dest)
 186     {
 187         if (boost::addressof(src) != boost::addressof(dest))
 188             dest = std::move(src);
 189     }
 190
 191     template <typename T>
 192     inline void move_to(T const& src, T& dest)
 193     {
 194         if (boost::addressof(src) != boost::addressof(dest))
 195             dest = std::move(src);
 196     }
 197
 198     template <typename T>
 199     inline void move_to(T&& src, T& dest)
 200     {
 201         if (boost::addressof(src) != boost::addressof(dest))
 202             dest = std::move(src);
 203     }
 204
 205     template <typename Iterator, typename Dest>
 206     inline void move_to(Iterator first, Iterator last, Dest& dest)
 207     {
 208         // $$$ Use std::move_iterator when iterator is not a const-iterator $$$
 209         detail::move_to(first, last, dest, typename attribute_category<Dest>::type());
 210     }
 211 }}}}
 212
 213 #endif