PageRenderTime 38ms CodeModel.GetById 23ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/spirit/home/karma/generate_attr.hpp

http://hadesmem.googlecode.com/
C++ Header | 212 lines | 161 code | 29 blank | 22 comment | 2 complexity | 998a24c66734a36c087dd0d66e6af581 MD5 | raw file
  1//  Copyright (c) 2001-2011 Hartmut Kaiser
  2// 
  3//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
  4//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  5
  6#if !defined(BOOST_PP_IS_ITERATING)
  7
  8#if !defined(BOOST_SPIRIT_KARMA_GENERATE_ATTR_APR_23_2009_0541PM)
  9#define BOOST_SPIRIT_KARMA_GENERATE_ATTR_APR_23_2009_0541PM
 10
 11#include <boost/spirit/home/karma/generate.hpp>
 12
 13#include <boost/fusion/include/vector.hpp>
 14#include <boost/preprocessor/cat.hpp>
 15#include <boost/preprocessor/iterate.hpp>
 16#include <boost/preprocessor/repetition/enum.hpp>
 17#include <boost/preprocessor/repetition/enum_params.hpp>
 18#include <boost/preprocessor/repetition/enum_binary_params.hpp>
 19
 20#define BOOST_PP_FILENAME_1 <boost/spirit/home/karma/generate_attr.hpp>
 21#define BOOST_PP_ITERATION_LIMITS (2, SPIRIT_ARGUMENTS_LIMIT)
 22#include BOOST_PP_ITERATE()
 23
 24#endif
 25
 26///////////////////////////////////////////////////////////////////////////////
 27//
 28//  Preprocessor vertical repetition code
 29//
 30///////////////////////////////////////////////////////////////////////////////
 31#else // defined(BOOST_PP_IS_ITERATING)
 32
 33#define N BOOST_PP_ITERATION()
 34#define BOOST_SPIRIT_KARMA_ATTRIBUTE_REFERENCE(z, n, A)                       \
 35    BOOST_PP_CAT(A, n) const&
 36
 37namespace boost { namespace spirit { namespace karma
 38{
 39    ///////////////////////////////////////////////////////////////////////////
 40    template <typename OutputIterator, typename Properties, typename Expr
 41      , BOOST_PP_ENUM_PARAMS(N, typename A)>
 42    inline bool
 43    generate(
 44        detail::output_iterator<OutputIterator, Properties>& sink
 45      , Expr const& expr
 46      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
 47    {
 48        // Report invalid expression error as early as possible.
 49        // If you got an error_invalid_expression error message here,
 50        // then the expression (expr) is not a valid spirit karma expression.
 51        BOOST_SPIRIT_ASSERT_MATCH(karma::domain, Expr);
 52
 53        typedef fusion::vector<
 54            BOOST_PP_ENUM(N, BOOST_SPIRIT_KARMA_ATTRIBUTE_REFERENCE, A)
 55        > vector_type;
 56
 57        vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr));
 58        return compile<karma::domain>(expr).generate(sink, unused, unused, attr);
 59    }
 60
 61    template <typename OutputIterator, typename Expr
 62      , BOOST_PP_ENUM_PARAMS(N, typename A)>
 63    inline bool
 64    generate(
 65        OutputIterator& sink_
 66      , Expr const& expr
 67      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
 68    {
 69        typedef traits::properties_of<
 70            typename result_of::compile<karma::domain, Expr>::type
 71        > properties;
 72
 73        // wrap user supplied iterator into our own output iterator
 74        detail::output_iterator<OutputIterator
 75          , mpl::int_<properties::value> > sink(sink_);
 76        return karma::generate(sink, expr, BOOST_PP_ENUM_PARAMS(N, attr));
 77    }
 78
 79    template <typename OutputIterator, typename Expr
 80      , BOOST_PP_ENUM_PARAMS(N, typename A)>
 81    inline bool
 82    generate(
 83        OutputIterator const& sink_
 84      , Expr const& expr
 85      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
 86    {
 87        OutputIterator sink = sink_;
 88        return karma::generate(sink, expr, BOOST_PP_ENUM_PARAMS(N, attr));
 89    }
 90
 91    ///////////////////////////////////////////////////////////////////////////
 92    template <typename OutputIterator, typename Properties, typename Expr
 93      , typename Delimiter, BOOST_PP_ENUM_PARAMS(N, typename A)>
 94    inline bool
 95    generate_delimited(
 96        detail::output_iterator<OutputIterator, Properties>& sink
 97      , Expr const& expr
 98      , Delimiter const& delimiter
 99      , BOOST_SCOPED_ENUM(delimit_flag) pre_delimit
100      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
101    {
102        // Report invalid expression error as early as possible.
103        // If you got an error_invalid_expression error message here,
104        // then either the expression (expr) or skipper is not a valid
105        // spirit karma expression.
106        BOOST_SPIRIT_ASSERT_MATCH(karma::domain, Expr);
107        BOOST_SPIRIT_ASSERT_MATCH(karma::domain, Delimiter);
108
109        typename result_of::compile<karma::domain, Delimiter>::type const 
110            delimiter_ = compile<karma::domain>(delimiter);
111
112        if (pre_delimit == delimit_flag::predelimit &&
113            !karma::delimit_out(sink, delimiter_))
114        {
115            return false;
116        }
117
118        typedef fusion::vector<
119            BOOST_PP_ENUM(N, BOOST_SPIRIT_KARMA_ATTRIBUTE_REFERENCE, A)
120        > vector_type;
121
122        vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr));
123        return compile<karma::domain>(expr).
124            generate(sink, unused, delimiter_, attr);
125    }
126
127    template <typename OutputIterator, typename Expr, typename Delimiter
128      , BOOST_PP_ENUM_PARAMS(N, typename A)>
129    inline bool
130    generate_delimited(
131        OutputIterator& sink_
132      , Expr const& expr
133      , Delimiter const& delimiter
134      , BOOST_SCOPED_ENUM(delimit_flag) pre_delimit
135      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
136    {
137        typedef traits::properties_of<
138            typename result_of::compile<karma::domain, Expr>::type
139        > properties;
140        typedef traits::properties_of<
141            typename result_of::compile<karma::domain, Delimiter>::type
142        > delimiter_properties;
143
144        // wrap user supplied iterator into our own output iterator
145        detail::output_iterator<OutputIterator
146          , mpl::int_<properties::value | delimiter_properties::value>
147        > sink(sink_);
148        return karma::generate_delimited(sink, expr, delimiter, pre_delimit
149          , BOOST_PP_ENUM_PARAMS(N, attr));
150    }
151
152    template <typename OutputIterator, typename Expr, typename Delimiter
153      , BOOST_PP_ENUM_PARAMS(N, typename A)>
154    inline bool
155    generate_delimited(
156        OutputIterator const& sink_
157      , Expr const& expr
158      , Delimiter const& delimiter
159      , BOOST_SCOPED_ENUM(delimit_flag) pre_delimit
160      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
161    {
162        OutputIterator sink = sink_;
163        return karma::generate_delimited(sink, expr, delimiter, pre_delimit
164          , BOOST_PP_ENUM_PARAMS(N, attr));
165    }
166
167    ///////////////////////////////////////////////////////////////////////////
168    template <typename OutputIterator, typename Expr, typename Delimiter
169      , BOOST_PP_ENUM_PARAMS(N, typename A)>
170    inline bool
171    generate_delimited(
172        OutputIterator& sink_
173      , Expr const& expr
174      , Delimiter const& delimiter
175      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
176    {
177        typedef traits::properties_of<
178            typename result_of::compile<karma::domain, Expr>::type
179        > properties;
180        typedef traits::properties_of<
181            typename result_of::compile<karma::domain, Delimiter>::type
182        > delimiter_properties;
183
184        // wrap user supplied iterator into our own output iterator
185        detail::output_iterator<OutputIterator
186          , mpl::int_<properties::value | delimiter_properties::value>
187        > sink(sink_);
188        return karma::generate_delimited(sink, expr, delimiter
189          , delimit_flag::dont_predelimit, BOOST_PP_ENUM_PARAMS(N, attr));
190    }
191
192    template <typename OutputIterator, typename Expr, typename Delimiter
193      , BOOST_PP_ENUM_PARAMS(N, typename A)>
194    inline bool
195    generate_delimited(
196        OutputIterator const& sink_
197      , Expr const& expr
198      , Delimiter const& delimiter
199      , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr))
200    {
201        OutputIterator sink = sink_;
202        return karma::generate_delimited(sink, expr, delimiter 
203          , delimit_flag::dont_predelimit, BOOST_PP_ENUM_PARAMS(N, attr));
204    }
205
206}}}
207
208#undef BOOST_SPIRIT_KARMA_ATTRIBUTE_REFERENCE
209#undef N
210
211#endif // defined(BOOST_PP_IS_ITERATING)
212