Ticket #5858: BoostPreprocessor.i

File BoostPreprocessor.i, 14.4 KB (added by SergK13Stuff@…, 11 years ago)

PreprocessorOutput (stripped)

Line 
1namespace boost_concept{
2 template < typename Iterator > struct ReadableIterator; template < typename Iterator > struct ReadableIteratorConcept : ReadableIterator< Iterator > { }; template < typename Iterator > struct ReadableIterato : boost::Assignable<Iterator , boost::CopyConstructible<Iterator
3 {
4 typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
5 typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
6
7 enum { boost_concept_check50 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<ReadableIterator>))0)) }; ~ReadableIterator()
8 {
9
10 value_type v = *i;
11 boost::ignore_unused_variable_warning(v);
12 }
13 private Iterator i;
14 };
15 template typename Iterato , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
16 struct WritableIterato : boost::CopyConstructible<Iterator {
17 enum { boost_concept_check67 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<WritableIterator>))0)) }; ~WritableIterator()
18 {
19 *i = v;
20 }
21 private ValueType v;
22 Iterator i;
23 };
24
25 template typename Iterato , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
26 struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
27 template < typename Iterator > struct SwappableIterator; template < typename Iterator > struct SwappableIteratorConcept : SwappableIterator< Iterator > { }; template < typename Iterator > struct SwappableIterato {
28 enum { boost_concept_check84 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<SwappableIterator>))0)) }; ~SwappableIterator()
29 {
30 std::iter_swap(i1, i2);
31 }
32 private Iterator i1;
33 Iterator i2;
34 };
35
36 template < typename Iterator > struct LvalueIterator; template < typename Iterator > struct LvalueIteratorConcept : LvalueIterator< Iterator > { }; template < typename Iterator > struct LvalueIterato {
37 typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
38 enum { boost_concept_check97 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<LvalueIterator>))0)) }; ~LvalueIterator()
39 {
40 value_type& r = const_cast<value_type&>(*i);
41 boost::ignore_unused_variable_warning(r);
42 }
43 private Iterator i;
44 };
45
46 template < typename Iterator > struct IncrementableIterator; template < typename Iterator > struct IncrementableIteratorConcept : IncrementableIterator< Iterator > { }; template < typename Iterator > struct IncrementableIterato : boost::Assignable<Iterator , boost::CopyConstructible<Iterator {
47 typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
48
49 enum { boost_concept_check120 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< traversal_category , boost::incrementable_traversal_tag >))0)) };
50
51
52 enum { boost_concept_check122 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<IncrementableIterator>))0)) }; ~IncrementableIterator()
53 {
54 ++i;
55 (void)i++;
56 }
57 private Iterator i;
58 };
59
60 template < typename Iterator > struct SinglePassIterator; template < typename Iterator > struct SinglePassIteratorConcept : SinglePassIterator< Iterator > { }; template < typename Iterator > struct SinglePassIterato : IncrementableIterator<Iterator , boost::EqualityComparable<Iterator
61 {
62 enum { boost_concept_check140 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename SinglePassIterator::traversal_category , boost::single_pass_traversal_tag > ))0)) };
63
64 };
65
66 template < typename Iterator > struct ForwardTraversal; template < typename Iterator > struct ForwardTraversalConcept : ForwardTraversal< Iterator > { }; template < typename Iterator > struct ForwardTraversa : SinglePassIterator<Iterator , boost::DefaultConstructible<Iterator {
67 typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
68 static const std::size_t mpl_assertion_in_line_14 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_integral<difference_type>))0, 1 ) ) );
69 static const std::size_t mpl_assertion_in_line_15 = sizeof( boost::mpl::assertion_failed<(std::numeric_limits<difference_type>::is_signed == true)>( (boost::mpl::failed ************ ( boost::mpl::assert_relation<std::numeric_limits<difference_type>::is_signed,true,(&boost::mpl::operator ==)>::************))0 ) );
70
71 enum { boost_concept_check156 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename ForwardTraversal::traversal_category , boost::forward_traversal_tag > ))0)) };
72
73 };
74 template < typename Iterator > struct BidirectionalTraversal; template < typename Iterator > struct BidirectionalTraversalConcept : BidirectionalTraversal< Iterator > { }; template < typename Iterator > struct BidirectionalTraversa : ForwardTraversal<Iterator {
75 enum { boost_concept_check166 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename BidirectionalTraversal::traversal_category , boost::bidirectional_traversal_tag > ))0)) };
76
77
78 enum { boost_concept_check168 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<BidirectionalTraversal>))0)) }; ~BidirectionalTraversal()
79 {
80 --i;
81 (void)i--;
82 }
83 private Iterator i;
84 };
85
86 template < typename Iterator > struct RandomAccessTraversal; template < typename Iterator > struct RandomAccessTraversalConcept : RandomAccessTraversal< Iterator > { }; template < typename Iterator > struct RandomAccessTraversa : BidirectionalTraversal<Iterator {
87 enum { boost_concept_check184 = sizeof(::boost::concept::require_((void(*)( boost::Convertible< typename RandomAccessTraversal::traversal_category , boost::random_access_traversal_tag > ))0)) };
88
89
90 enum { boost_concept_check186 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<RandomAccessTraversal>))0)) }; ~RandomAccessTraversal()
91 {
92 i += n;
93 i = i + n;
94 i = n + i;
95 i -= n;
96 i = i - n;
97 n = i - j;
98 }
99 private typename BidirectionalTraversal<Iterator>::difference_type n;
100 Iterator i, j;
101 };
102
103 namespace detai {
104 template <typename Iterator1, typename Iterator2 void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
105 {
106 bool b;
107 b = i1 == i2;
108 b = i1 != i2;
109
110 b = i2 == i1;
111 b = i2 != i1;
112 boost::ignore_unused_variable_warning(b);
113 }
114
115 template <typename Iterator1, typename Iterator2 void interop_rand_access_constraints(
116 Iterator1 const& i1, Iterator2 const& i2 boost::random_access_traversal_tag, boost::random_access_traversal_tag)
117 {
118 bool b;
119 typename boost::detail::iterator_traits<Iterator2>::difference_type n;
120 b = i1 < i2;
121 b = i1 <= i2;
122 b = i1 > i2;
123 b = i1 >= i2;
124 n = i1 - i2;
125
126 b = i2 < i1;
127 b = i2 <= i1;
128 b = i2 > i1;
129 b = i2 >= i1;
130 n = i2 - i1;
131 boost::ignore_unused_variable_warning(b);
132 boost::ignore_unused_variable_warning(n);
133 }
134
135 template <typename Iterator1, typename Iterator2 void interop_rand_access_constraints(
136 Iterator1 const&, Iterator2 const& boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
137 { }
138
139 }
140 template < typename Iterator , typename ConstIterator > struct InteroperableIterator; template < typename Iterator , typename ConstIterator > struct InteroperableIteratorConcept : InteroperableIterator< Iterator, ConstIterator > { }; template < typename Iterator , typename ConstIterator > struct InteroperableIterato {
141 private typedef typename boost::detail::pure_traversal_tag typename boost::iterator_traversal Iterato >::type
142 >::type traversal_category;
143
144 typedef typename boost::detail::pure_traversal_tag typename boost::iterator_traversal ConstIterato >::type
145 >::type const_traversal_category;
146 public enum { boost_concept_check264 = sizeof(::boost::concept::require_((void(*)(SinglePassIterator<Iterator>))0)) };
147 enum { boost_concept_check265 = sizeof(::boost::concept::require_((void(*)(SinglePassIterator<ConstIterator>))0)) };
148
149 enum { boost_concept_check267 = sizeof(::boost::concept::require_((void(*)(boost::concept::usage_requirements<InteroperableIterator>))0)) }; ~InteroperableIterator()
150 {
151 detail::interop_single_pass_constraints(i, ci);
152 detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
153
154 ci = i;
155 }
156 private Iterator i;
157 ConstIterator ci;
158 };
159
160}
161
162namespace boost {
163namespace detail {
164namespace multi_array {
165
166 template <std::size_t N struct idgen_helper {
167
168 template <typename Array, typename IdxGen, typename Call_Type static void call(Array& a, const IdxGen& idgen, Call_Type c) {
169 typedef typename Array::index_range index_range;
170 typedef typename Array::index index;
171 idgen_helper<N-1>::call(a,idgen[c],c);
172 }
173 };
174
175 template < struct idgen_helper<0> {
176
177 template <typename Array, typename IdxGen, typename Call_Type static void call(Array& a, const IdxGen& idgen, Call_Type) {
178 typedef typename Array::index_range index_range;
179 typedef typename Array::index index;
180 a[ idgen ];
181 }
182 };
183
184
185 template <typename Array, std::size_t NumDims struct ConstMultiArrayConcep {
186 void constraints() {
187 function_requires< boost_concepts::ForwardTraversalConcept<iterator> >();
188 function_requires< boost_concepts::ReadableIteratorConcept<iterator> >();
189 function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
190 function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();
191
192 a[ id ];
193 idgen_helper<NumDims-1>::call(a,idgen[range],id);
194
195 idgen_helper<NumDims-1>::call(a,idgen[range],range);
196
197 st = a.size();
198 st = a.num_dimensions();
199 st = Array::dimensionality;
200 st = a.num_elements();
201 stp = a.shape();
202 idp = a.strides();
203 idp = a.index_bases();
204 cit = a.begin();
205 cit = a.end();
206 crit = a.rbegin();
207 crit = a.rend();
208 eltp = a.origin();
209 }
210
211 typedef typename Array::value_type value_type;
212 typedef typename Array::reference reference;
213 typedef typename Array::const_reference const_reference;
214 typedef typename Array::size_type size_type;
215 typedef typename Array::difference_type difference_type;
216 typedef typename Array::iterator iterator;
217 typedef typename Array::const_iterator const_iterator;
218 typedef typename Array::reverse_iterator reverse_iterator;
219 typedef typename Array::const_reverse_iterator const_reverse_iterator;
220 typedef typename Array::element element;
221 typedef typename Array::index index;
222 typedef typename Array::index_gen index_gen;
223 typedef typename Array::index_range index_range;
224 typedef typename Array::extent_gen extent_gen;
225 typedef typename Array::extent_range extent_range;
226
227 Array a;
228 size_type st;
229 const size_type* stp;
230 index id;
231 const index* idp;
232 const_iterator cit;
233 const_reverse_iterator crit;
234 const element* eltp;
235 index_gen idgen;
236 index_range range;
237 };
238
239
240 template <typename Array, std::size_t NumDims struct MutableMultiArrayConcep {
241 void constraints() {
242 function_requires< boost_concepts::ForwardTraversalConcept<iterator> >();
243 function_requires< boost_concepts::ReadableIteratorConcept<iterator> >();
244 function_requires< boost_concepts::WritableIteratorConcept<iterator> >();
245 function_requires< boost_concepts::ForwardTraversalConcept<const_iterator> >();
246 function_requires< boost_concepts::ReadableIteratorConcept<const_iterator> >();
247 value_type vt = a[ id ];
248
249 idgen_helper<NumDims-1>::call(a,idgen[range],id);
250
251 idgen_helper<NumDims-1>::call(a,idgen[range],range);
252
253 st = a.size();
254 st = a.num_dimensions();
255 st = a.num_elements();
256 stp = a.shape();
257 idp = a.strides();
258 idp = a.index_bases();
259 it = a.begin();
260 it = a.end();
261 rit = a.rbegin();
262 rit = a.rend();
263 eltp = a.origin();
264 const_constraints(a);
265 }
266
267 void const_constraints(const Array& a) {
268
269 idgen_helper<NumDims-1>::call(a,idgen[range],id);
270
271 idgen_helper<NumDims-1>::call(a,idgen[range],range);
272
273 st = a.size();
274 st = a.num_dimensions();
275 st = a.num_elements();
276 stp = a.shape();
277 idp = a.strides();
278 idp = a.index_bases();
279 cit = a.begin();
280 cit = a.end();
281 crit = a.rbegin();
282 crit = a.rend();
283 eltp = a.origin();
284 }
285
286 typedef typename Array::value_type value_type;
287 typedef typename Array::reference reference;
288 typedef typename Array::const_reference const_reference;
289 typedef typename Array::size_type size_type;
290 typedef typename Array::difference_type difference_type;
291 typedef typename Array::iterator iterator;
292 typedef typename Array::const_iterator const_iterator;
293 typedef typename Array::reverse_iterator reverse_iterator;
294 typedef typename Array::const_reverse_iterator const_reverse_iterator;
295 typedef typename Array::element element;
296 typedef typename Array::index index;
297 typedef typename Array::index_gen index_gen;
298 typedef typename Array::index_range index_range;
299 typedef typename Array::extent_gen extent_gen;
300 typedef typename Array::extent_range extent_range;
301
302 Array a;
303 size_type st;
304 const size_type* stp;
305 index id;
306 const index* idp;
307 iterator it;
308 const_iterator cit;
309 reverse_iterator rit;
310 const_reverse_iterator crit;
311 const element* eltp;
312 index_gen idgen;
313 index_range range;
314 };
315
316
317}}}