[ceph.git] / ceph / src / boost / libs / spirit / include / boost / spirit / home / qi / detail / assign_to.hpp

/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
    Copyright (c) 2001-2011 Hartmut Kaiser
    http://spirit.sourceforge.net/

    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_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM)
#define BOOST_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/spirit/home/qi/detail/construct.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/qi/detail/attributes.hpp>
#include <boost/spirit/home/support/container.hpp>
#include <boost/fusion/include/copy.hpp>
#include <boost/fusion/adapted/struct/detail/extension.hpp>
#include <boost/ref.hpp>
#include <boost/range/iterator_range.hpp>

namespace boost { namespace spirit { namespace traits
{
    ///////////////////////////////////////////////////////////////////////////
    //  This file contains assignment utilities. The utilities provided also
    //  accept spirit's unused_type; all no-ops. Compiler optimization will
    //  easily strip these away.
    ///////////////////////////////////////////////////////////////////////////
    namespace detail
    {
        template <typename T>
        struct is_iter_range : mpl::false_ {};

        template <typename I>
        struct is_iter_range<boost::iterator_range<I> > : mpl::true_ {};

        template <typename C>
        struct is_container_of_ranges
          : is_iter_range<typename C::value_type> {};
    }

    template <typename Attribute, typename Iterator, typename Enable>
    struct assign_to_attribute_from_iterators
    {
        // Common case
        static void
        call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::false_)
        {
            if (traits::is_empty(attr))
                attr = Attribute(first, last);
            else {
                for (Iterator i = first; i != last; ++i)
                    push_back(attr, *i);
            }
        }

        // If Attribute is a container with value_type==iterator_range<T> just push the
        // iterator_range into it
        static void
        call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::true_)
        {
            typename Attribute::value_type rng(first, last);
            push_back(attr, rng);
        }

        static void
        call(Iterator const& first, Iterator const& last, Attribute& attr)
        {
            call(first, last, attr, detail::is_container_of_ranges<Attribute>());
        }
    };

    template <typename Attribute, typename Iterator>
    struct assign_to_attribute_from_iterators<
        reference_wrapper<Attribute>, Iterator>
    {
        static void
        call(Iterator const& first, Iterator const& last
          , reference_wrapper<Attribute> attr)
        {
            if (traits::is_empty(attr))
                attr = Attribute(first, last);
            else {
                for (Iterator i = first; i != last; ++i)
                    push_back(attr, *i);
            }
        }
    };

    template <typename Attribute, typename Iterator>
    struct assign_to_attribute_from_iterators<
        boost::optional<Attribute>, Iterator>
    {
        static void
        call(Iterator const& first, Iterator const& last
          , boost::optional<Attribute>& attr)
        {
            Attribute val;
            assign_to(first, last, val);
            attr = val;
        }
    };

    template <typename Iterator>
    struct assign_to_attribute_from_iterators<
        iterator_range<Iterator>, Iterator>
    {
        static void
        call(Iterator const& first, Iterator const& last
          , iterator_range<Iterator>& attr)
        {
            attr = iterator_range<Iterator>(first, last);
        }
    };

    template <typename Iterator, typename Attribute>
    inline void
    assign_to(Iterator const& first, Iterator const& last, Attribute& attr)
    {
        assign_to_attribute_from_iterators<Attribute, Iterator>::
            call(first, last, attr);
    }

    template <typename Iterator>
    inline void
    assign_to(Iterator const&, Iterator const&, unused_type)
    {
    }

    ///////////////////////////////////////////////////////////////////////////
    template <typename T, typename Attribute>
    void assign_to(T const& val, Attribute& attr);

    template <typename Attribute, typename T, typename Enable>
    struct assign_to_attribute_from_value
    {
        typedef typename traits::one_element_sequence<Attribute>::type
            is_one_element_sequence;

        typedef typename mpl::eval_if<
            is_one_element_sequence
          , fusion::result_of::at_c<Attribute, 0>
          , mpl::identity<Attribute&>
        >::type type;

        template <typename T_>
        static void
        call(T_ const& val, Attribute& attr, mpl::false_)
        {
            attr = static_cast<Attribute>(val);
        }

        // This handles the case where the attribute is a single element fusion
        // sequence. We silently assign to the only element and treat it as the
        // attribute to parse the results into.
        template <typename T_>
        static void
        call(T_ const& val, Attribute& attr, mpl::true_)
        {
            typedef typename fusion::result_of::value_at_c<Attribute, 0>::type
                element_type;
            fusion::at_c<0>(attr) = static_cast<element_type>(val);
        }

        static void
        call(T const& val, Attribute& attr)
        {
            call(val, attr, is_one_element_sequence());
        }
    };

    template <typename Attribute>
    struct assign_to_attribute_from_value<Attribute, Attribute>
    {
        static void
        call(Attribute const& val, Attribute& attr)
        {
            attr = val;
        }
    };

    template <typename Attribute, typename T>
    struct assign_to_attribute_from_value<Attribute, reference_wrapper<T>
      , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
    {
        static void
        call(reference_wrapper<T> const& val, Attribute& attr)
        {
            assign_to(val.get(), attr);
        }
    };

    template <typename Attribute, typename T>
    struct assign_to_attribute_from_value<Attribute, boost::optional<T>
      , typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
    {
        static void
        call(boost::optional<T> const& val, Attribute& attr)
        {
            assign_to(val.get(), attr);
        }
    };

    template <typename Attribute, int N, bool Const, typename T>
    struct assign_to_attribute_from_value<fusion::extension::adt_attribute_proxy<Attribute, N, Const>, T>
    {
        static void
        call(T const& val, typename fusion::extension::adt_attribute_proxy<Attribute, N, Const>& attr)
        {
            attr = val;
        }
    };

    namespace detail
    {
        template <typename A, typename B>
        struct is_same_size_sequence
          : mpl::bool_<fusion::result_of::size<A>::value
                == fusion::result_of::size<B>::value>
        {};
    }

    template <typename Attribute, typename T>
    struct assign_to_attribute_from_value<Attribute, T,
            mpl::and_<
                fusion::traits::is_sequence<Attribute>,
                fusion::traits::is_sequence<T>,
                detail::is_same_size_sequence<Attribute, T>
            >
        >
    {
        static void
        call(T const& val, Attribute& attr)
        {
            fusion::copy(val, attr);
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    template <typename Attribute, typename T, typename Enable>
    struct assign_to_container_from_value
    {
        // T is not a container and not a string
        template <typename T_>
        static void call(T_ const& val, Attribute& attr, mpl::false_, mpl::false_)
        {
            traits::push_back(attr, val);
        }

        // T is a container (but not a string), and T is convertible to the 
        // value_type of the Attribute container
        template <typename T_>
        static void 
        append_to_container_not_string(T_ const& val, Attribute& attr, mpl::true_)
        {
            traits::push_back(attr, val);
        }

        // T is a container (but not a string), generic overload
        template <typename T_>
        static void 
        append_to_container_not_string(T_ const& val, Attribute& attr, mpl::false_)
        {
            typedef typename traits::container_iterator<T_ const>::type
                iterator_type;

            iterator_type end = traits::end(val);
            for (iterator_type i = traits::begin(val); i != end; traits::next(i))
                traits::push_back(attr, traits::deref(i));
        }

        // T is a container (but not a string)
        template <typename T_>
        static void call(T_ const& val, Attribute& attr,  mpl::true_, mpl::false_)
        {
            typedef typename container_value<Attribute>::type value_type;
            typedef typename is_convertible<T, value_type>::type is_value_type;

            append_to_container_not_string(val, attr, is_value_type());
        }

        ///////////////////////////////////////////////////////////////////////
        // T is a string
        template <typename Iterator>
        static void append_to_string(Attribute& attr, Iterator begin, Iterator end)
        {
            for (Iterator i = begin; i != end; ++i)
                traits::push_back(attr, *i);
        }

        // T is string, but not convertible to value_type of container
        template <typename T_>
        static void append_to_container(T_ const& val, Attribute& attr, mpl::false_)
        {
            typedef typename char_type_of<T_>::type char_type;

            append_to_string(attr, traits::get_begin<char_type>(val)
              , traits::get_end<char_type>(val));
        }

        // T is string, and convertible to value_type of container
        template <typename T_>
        static void append_to_container(T_ const& val, Attribute& attr, mpl::true_)
        {
            traits::push_back(attr, val);
        }

        template <typename T_, typename Pred>
        static void call(T_ const& val, Attribute& attr, Pred, mpl::true_)
        {
            typedef typename container_value<Attribute>::type value_type;
            typedef typename is_convertible<T, value_type>::type is_value_type;

            append_to_container(val, attr, is_value_type());
        }

        ///////////////////////////////////////////////////////////////////////
        static void call(T const& val, Attribute& attr)
        {
            typedef typename traits::is_container<T>::type is_container;
            typedef typename traits::is_string<T>::type is_string;

            call(val, attr, is_container(), is_string());
        }
    };

    template <typename Attribute>
    struct assign_to_container_from_value<Attribute, Attribute>
    {
        static void
        call(Attribute const& val, Attribute& attr)
        {
            attr = val;
        }
    };

    template <typename Attribute, typename T>
    struct assign_to_container_from_value<Attribute, boost::optional<T>
      , typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
    {
        static void
        call(boost::optional<T> const& val, Attribute& attr)
        {
            assign_to(val.get(), attr);
        }
    };

    template <typename Attribute, typename T>
    struct assign_to_container_from_value<Attribute, reference_wrapper<T>
      , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
    {
        static void
        call(reference_wrapper<T> const& val, Attribute& attr)
        {
            assign_to(val.get(), attr);
        }
    };

    ///////////////////////////////////////////////////////////////////////////
    namespace detail
    {
        // overload for non-container attributes
        template <typename T, typename Attribute>
        inline void
        assign_to(T const& val, Attribute& attr, mpl::false_)
        {
            assign_to_attribute_from_value<Attribute, T>::call(val, attr);
        }

        // overload for containers (but not for variants or optionals
        // holding containers)
        template <typename T, typename Attribute>
        inline void
        assign_to(T const& val, Attribute& attr, mpl::true_)
        {
            assign_to_container_from_value<Attribute, T>::call(val, attr);
        }
    }

    template <typename T, typename Attribute>
    inline void
    assign_to(T const& val, Attribute& attr)
    {
        typedef typename mpl::and_<
            traits::is_container<Attribute>
          , traits::not_is_variant<Attribute>
          , traits::not_is_optional<Attribute>
        >::type is_not_wrapped_container;

        detail::assign_to(val, attr, is_not_wrapped_container());
    }

    template <typename T>
    inline void
    assign_to(T const&, unused_type)
    {
    }
}}}

#endif
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
	2	Copyright (c) 2001-2011 Joel de Guzman
	3	Copyright (c) 2001-2011 Hartmut Kaiser
	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_ASSIGN_TO_APR_16_2006_0812PM)
	10	#define BOOST_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM
	11
	12	#if defined(_MSC_VER)
	13	#pragma once
	14	#endif
	15
	16	#include <boost/spirit/home/qi/detail/construct.hpp>
	17	#include <boost/spirit/home/support/unused.hpp>
	18	#include <boost/spirit/home/qi/detail/attributes.hpp>
	19	#include <boost/spirit/home/support/container.hpp>
	20	#include <boost/fusion/include/copy.hpp>
	21	#include <boost/fusion/adapted/struct/detail/extension.hpp>
	22	#include <boost/ref.hpp>
	23	#include <boost/range/iterator_range.hpp>
	24
	25	namespace boost { namespace spirit { namespace traits
	26	{
	27	///////////////////////////////////////////////////////////////////////////
	28	// This file contains assignment utilities. The utilities provided also
	29	// accept spirit's unused_type; all no-ops. Compiler optimization will
	30	// easily strip these away.
	31	///////////////////////////////////////////////////////////////////////////
	32	namespace detail
	33	{
	34	template <typename T>
	35	struct is_iter_range : mpl::false_ {};
	36
	37	template <typename I>
	38	struct is_iter_range<boost::iterator_range<I> > : mpl::true_ {};
	39
	40	template <typename C>
	41	struct is_container_of_ranges
	42	: is_iter_range<typename C::value_type> {};
	43	}
	44
	45	template <typename Attribute, typename Iterator, typename Enable>
	46	struct assign_to_attribute_from_iterators
	47	{
	48	// Common case
	49	static void
	50	call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::false_)
	51	{
	52	if (traits::is_empty(attr))
	53	attr = Attribute(first, last);
	54	else {
	55	for (Iterator i = first; i != last; ++i)
	56	push_back(attr, *i);
	57	}
	58	}
	59
	60	// If Attribute is a container with value_type==iterator_range<T> just push the
	61	// iterator_range into it
	62	static void
	63	call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::true_)
	64	{
65	typename Attribute::value_type rng(first, last);
66	push_back(attr, rng);
67	}
68
69	static void
70	call(Iterator const& first, Iterator const& last, Attribute& attr)
71	{
72	call(first, last, attr, detail::is_container_of_ranges<Attribute>());
73	}
74	};
75
76	template <typename Attribute, typename Iterator>
77	struct assign_to_attribute_from_iterators<
78	reference_wrapper<Attribute>, Iterator>
79	{
80	static void
81	call(Iterator const& first, Iterator const& last
82	, reference_wrapper<Attribute> attr)
83	{
84	if (traits::is_empty(attr))
85	attr = Attribute(first, last);
86	else {
87	for (Iterator i = first; i != last; ++i)
88	push_back(attr, *i);
89	}
90	}
91	};
92
93	template <typename Attribute, typename Iterator>
94	struct assign_to_attribute_from_iterators<
95	boost::optional<Attribute>, Iterator>
96	{
97	static void
98	call(Iterator const& first, Iterator const& last
99	, boost::optional<Attribute>& attr)
100	{
101	Attribute val;
102	assign_to(first, last, val);
103	attr = val;
104	}
105	};
106
107	template <typename Iterator>
108	struct assign_to_attribute_from_iterators<
109	iterator_range<Iterator>, Iterator>
110	{
111	static void
112	call(Iterator const& first, Iterator const& last
113	, iterator_range<Iterator>& attr)
114	{
115	attr = iterator_range<Iterator>(first, last);
116	}
117	};
118
119	template <typename Iterator, typename Attribute>
120	inline void
121	assign_to(Iterator const& first, Iterator const& last, Attribute& attr)
122	{
123	assign_to_attribute_from_iterators<Attribute, Iterator>::
124	call(first, last, attr);
125	}
126
127	template <typename Iterator>
128	inline void
129	assign_to(Iterator const&, Iterator const&, unused_type)
130	{
131	}
132
133	///////////////////////////////////////////////////////////////////////////
134	template <typename T, typename Attribute>
135	void assign_to(T const& val, Attribute& attr);
136
137	template <typename Attribute, typename T, typename Enable>
138	struct assign_to_attribute_from_value
139	{
140	typedef typename traits::one_element_sequence<Attribute>::type
141	is_one_element_sequence;
142
143	typedef typename mpl::eval_if<
144	is_one_element_sequence
145	, fusion::result_of::at_c<Attribute, 0>
146	, mpl::identity<Attribute&>
147	>::type type;
148
149	template <typename T_>
150	static void
151	call(T_ const& val, Attribute& attr, mpl::false_)
152	{
153	attr = static_cast<Attribute>(val);
154	}
155
156	// This handles the case where the attribute is a single element fusion
157	// sequence. We silently assign to the only element and treat it as the
158	// attribute to parse the results into.
159	template <typename T_>
160	static void
161	call(T_ const& val, Attribute& attr, mpl::true_)
162	{
163	typedef typename fusion::result_of::value_at_c<Attribute, 0>::type
164	element_type;
165	fusion::at_c<0>(attr) = static_cast<element_type>(val);
166	}
167
168	static void
169	call(T const& val, Attribute& attr)
170	{
171	call(val, attr, is_one_element_sequence());
172	}
173	};
174
175	template <typename Attribute>
176	struct assign_to_attribute_from_value<Attribute, Attribute>
177	{
178	static void
179	call(Attribute const& val, Attribute& attr)
180	{
181	attr = val;
182	}
183	};
184
185	template <typename Attribute, typename T>
186	struct assign_to_attribute_from_value<Attribute, reference_wrapper<T>
187	, typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
188	{
189	static void
190	call(reference_wrapper<T> const& val, Attribute& attr)
191	{
192	assign_to(val.get(), attr);
193	}
194	};
195
196	template <typename Attribute, typename T>
197	struct assign_to_attribute_from_value<Attribute, boost::optional<T>
198	, typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
199	{
200	static void
201	call(boost::optional<T> const& val, Attribute& attr)
202	{
203	assign_to(val.get(), attr);
204	}
205	};
206
207	template <typename Attribute, int N, bool Const, typename T>
208	struct assign_to_attribute_from_value<fusion::extension::adt_attribute_proxy<Attribute, N, Const>, T>
209	{
210	static void
211	call(T const& val, typename fusion::extension::adt_attribute_proxy<Attribute, N, Const>& attr)
212	{
213	attr = val;
214	}
215	};
216
217	namespace detail
218	{
219	template <typename A, typename B>
220	struct is_same_size_sequence
221	: mpl::bool_<fusion::result_of::size<A>::value
222	== fusion::result_of::size<B>::value>
223	{};
224	}
225
226	template <typename Attribute, typename T>
227	struct assign_to_attribute_from_value<Attribute, T,
228	mpl::and_<
229	fusion::traits::is_sequence<Attribute>,
230	fusion::traits::is_sequence<T>,
231	detail::is_same_size_sequence<Attribute, T>
232	>
233	>
234	{
235	static void
236	call(T const& val, Attribute& attr)
237	{
238	fusion::copy(val, attr);
239	}
240	};
241
242	///////////////////////////////////////////////////////////////////////////
243	template <typename Attribute, typename T, typename Enable>
244	struct assign_to_container_from_value
245	{
246	// T is not a container and not a string
247	template <typename T_>
248	static void call(T_ const& val, Attribute& attr, mpl::false_, mpl::false_)
249	{
250	traits::push_back(attr, val);
251	}
252
253	// T is a container (but not a string), and T is convertible to the
254	// value_type of the Attribute container
255	template <typename T_>
256	static void
257	append_to_container_not_string(T_ const& val, Attribute& attr, mpl::true_)
258	{
259	traits::push_back(attr, val);
260	}
261
262	// T is a container (but not a string), generic overload
263	template <typename T_>
264	static void
265	append_to_container_not_string(T_ const& val, Attribute& attr, mpl::false_)
266	{
267	typedef typename traits::container_iterator<T_ const>::type
268	iterator_type;
269
270	iterator_type end = traits::end(val);
271	for (iterator_type i = traits::begin(val); i != end; traits::next(i))
272	traits::push_back(attr, traits::deref(i));
273	}
274
275	// T is a container (but not a string)
276	template <typename T_>
277	static void call(T_ const& val, Attribute& attr, mpl::true_, mpl::false_)
278	{
279	typedef typename container_value<Attribute>::type value_type;
280	typedef typename is_convertible<T, value_type>::type is_value_type;
281
282	append_to_container_not_string(val, attr, is_value_type());
283	}
284
285	///////////////////////////////////////////////////////////////////////
286	// T is a string
287	template <typename Iterator>
288	static void append_to_string(Attribute& attr, Iterator begin, Iterator end)
289	{
290	for (Iterator i = begin; i != end; ++i)
291	traits::push_back(attr, *i);
292	}
293
294	// T is string, but not convertible to value_type of container
295	template <typename T_>
296	static void append_to_container(T_ const& val, Attribute& attr, mpl::false_)
297	{
298	typedef typename char_type_of<T_>::type char_type;
299
300	append_to_string(attr, traits::get_begin<char_type>(val)
301	, traits::get_end<char_type>(val));
302	}
303
304	// T is string, and convertible to value_type of container
305	template <typename T_>
306	static void append_to_container(T_ const& val, Attribute& attr, mpl::true_)
307	{
308	traits::push_back(attr, val);
309	}
310
311	template <typename T_, typename Pred>
312	static void call(T_ const& val, Attribute& attr, Pred, mpl::true_)
313	{
314	typedef typename container_value<Attribute>::type value_type;
315	typedef typename is_convertible<T, value_type>::type is_value_type;
316
317	append_to_container(val, attr, is_value_type());
318	}
319
320	///////////////////////////////////////////////////////////////////////
321	static void call(T const& val, Attribute& attr)
322	{
323	typedef typename traits::is_container<T>::type is_container;
324	typedef typename traits::is_string<T>::type is_string;
325
326	call(val, attr, is_container(), is_string());
327	}
328	};
329
330	template <typename Attribute>
331	struct assign_to_container_from_value<Attribute, Attribute>
332	{
333	static void
334	call(Attribute const& val, Attribute& attr)
335	{
336	attr = val;
337	}
338	};
339
340	template <typename Attribute, typename T>
341	struct assign_to_container_from_value<Attribute, boost::optional<T>
342	, typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
343	{
344	static void
345	call(boost::optional<T> const& val, Attribute& attr)
346	{
347	assign_to(val.get(), attr);
348	}
349	};
350
351	template <typename Attribute, typename T>
352	struct assign_to_container_from_value<Attribute, reference_wrapper<T>
353	, typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
354	{
355	static void
356	call(reference_wrapper<T> const& val, Attribute& attr)
357	{
358	assign_to(val.get(), attr);
359	}
360	};
361
362	///////////////////////////////////////////////////////////////////////////
363	namespace detail
364	{
365	// overload for non-container attributes
366	template <typename T, typename Attribute>
367	inline void
368	assign_to(T const& val, Attribute& attr, mpl::false_)
369	{
370	assign_to_attribute_from_value<Attribute, T>::call(val, attr);
371	}
372
373	// overload for containers (but not for variants or optionals
374	// holding containers)
375	template <typename T, typename Attribute>
376	inline void
377	assign_to(T const& val, Attribute& attr, mpl::true_)
378	{
379	assign_to_container_from_value<Attribute, T>::call(val, attr);
380	}
381	}
382
383	template <typename T, typename Attribute>
384	inline void
385	assign_to(T const& val, Attribute& attr)
386	{
387	typedef typename mpl::and_<
388	traits::is_container<Attribute>
389	, traits::not_is_variant<Attribute>
390	, traits::not_is_optional<Attribute>
391	>::type is_not_wrapped_container;
392
393	detail::assign_to(val, attr, is_not_wrapped_container());
394	}
395
396	template <typename T>
397	inline void
398	assign_to(T const&, unused_type)
399	{
400	}
401	}}}
402
403	#endif